@noodleseed/one 0.186.1 → 0.188.0

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

@@ -17,6 +17,7 @@ import { messagingProjectionIneligibility } from './messaging-eligibility.js';
 import { MetaCloud, WHATSAPP_META_CALLBACK_PATH } from './meta-cloud.js';
 import { boundReply } from './reply-bound.js';
 import { reviewButtonBinding } from './reply-buttons.js';
+import { TwilioSms } from './twilio-sms.js';
 export class WhatsAppRuntime {
     options;
     deps;
@@ -35,6 +36,18 @@ export class WhatsAppRuntime {
     async provider(binding) {
         const values = await this.deps.registry.configStore.resolveConfigValues('secret', resolveConfigScope(binding.tenant));
         const apiKey = values[binding.apiKeySecret];
+        if (binding.channel === 'sms') {
+            if (!apiKey)
+                throw new ChannelError('channel_credentials_missing');
+            const base = this.options.publicBaseUrl;
+            if (!base || !base.startsWith('https://'))
+                throw new ChannelError('sms_public_url_required');
+            await this.channels.checkCredentials(binding.id, channelDigest(JSON.stringify([apiKey])));
+            return {
+                adapter: new TwilioSms(apiKey, binding, `${base.replace(/\/$/, '')}/v1/channels/sms/webhooks/${binding.id}`, this.options.providerFetch),
+                webhookSecret: apiKey,
+            };
+        }
         if (binding.provider === 'meta') {
             const meta = this.options.meta;
             if (!meta)
@@ -62,7 +75,9 @@ export class WhatsAppRuntime {
         };
     }
     webhookUrl(req, binding) {
-        const base = this.deps.serviceBase(req).replace(/\/$/, '');
+        const base = (binding.channel === 'sms' ? (this.options.publicBaseUrl ?? '') : this.deps.serviceBase(req)).replace(/\/$/, '');
+        if (binding.channel === 'sms')
+            return `${base}/v1/channels/sms/webhooks/${binding.id}`;
         if (binding.channel === 'instagram')
             return `${base}${INSTAGRAM_META_CALLBACK_PATH}`;
         return binding.provider === 'meta'
@@ -79,7 +94,7 @@ export class WhatsAppRuntime {
         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);
-        const ineligible = messagingProjectionIneligibility(artifact);
+        const ineligible = messagingProjectionIneligibility(artifact, binding.channel);
         if (ineligible !== undefined)
             throw new ChannelError(ineligible);
         return { ...target, served: { ...target.served, artifact } };
@@ -129,7 +144,11 @@ export class WhatsAppRuntime {
         });
         await check('provider_asset', async () => {
             const health = await (await this.provider(binding)).adapter.health();
-            const asset = binding.channel === 'instagram' ? binding.instagramAccountId : binding.phoneNumberId;
+            const asset = binding.channel === 'sms'
+                ? binding.phoneNumberSid
+                : binding.channel === 'instagram'
+                    ? binding.instagramAccountId
+                    : binding.phoneNumberId;
             if (health.assetId !== asset)
                 throw new ChannelError('asset_mismatch');
             if (!health.canSend)
@@ -178,7 +197,7 @@ export class WhatsAppRuntime {
             return {
                 status: 'unavailable',
                 capabilities: [],
-                reason: `${channel === 'instagram' ? 'Instagram' : 'WhatsApp'} is not configured.`,
+                reason: `${channel === 'sms' ? 'SMS' : channel === 'instagram' ? 'Instagram' : 'WhatsApp'} is not configured.`,
             };
         const view = {
             bindingId: binding.id,
@@ -236,10 +255,12 @@ export class WhatsAppRuntime {
     }
     async blocks(id, after) {
         const local = await this.channels.blocks(id, after);
+        const optouts = await this.channels.optouts(id, after);
         const provider = await channelProviderBlocks(this.channels.store, id, this.channels.now(), after);
         const ids = [
             ...new Set([
                 ...local.map((item) => item.participantId),
+                ...optouts.map((item) => item.participantId),
                 ...provider.map((item) => item.participantId),
             ]),
         ];
@@ -248,14 +269,16 @@ export class WhatsAppRuntime {
             .slice(0, 100)
             .map((participantId) => {
             const block = local.find((item) => item.participantId === participantId);
+            const optout = optouts.find((item) => item.participantId === participantId);
             const match = provider.find((item) => item.participantId === participantId);
             return {
                 ...(block ?? {
                     participantId,
-                    actor: match.actor,
-                    reason: 'operator',
+                    actor: match?.actor ?? 'recipient',
+                    reason: match ? 'operator' : 'recipient_opt_out',
                     until: null,
                 }),
+                ...(optout ? { optedOut: optout.blocked } : {}),
                 local: !!block && (block.until === null || block.until > this.channels.now()),
                 ...(match
                     ? {
@@ -463,10 +486,15 @@ export class WhatsAppRuntime {
                     ? ((await this.deps.conversations?.retentionDays(binding.tenant, binding.channel, surface)) ?? 0)
                     : 0;
                 const kept = days > 0 ? ` ${historyNoticeSentence(days, surface.noticeTemplate)}` : '';
-                const disclosure = participant.history.length === 0
-                    ? `I’m ${artifact.server.branding?.name ?? artifact.server.title}’s AI assistant.${kept}\n\n`
-                    : '';
-                answer = disclosure + text.trim();
+                const brand = artifact.server.branding?.name ?? artifact.server.title;
+                const displayName = binding.channel === 'sms' ? [...brand].slice(0, 80).join('') : brand;
+                const disclosure = participant.history.length === 0 ? `I’m ${displayName}’s AI assistant.${kept}\n\n` : '';
+                answer =
+                    disclosure +
+                        text.trim() +
+                        (binding.channel === 'sms' && participant.history.length === 0
+                            ? '\nReply STOP to unsubscribe.'
+                            : '');
             }
             const bounded = boundReply(binding.channel, answer);
             // Marked-private values never persist: history and the event row keep redacted text, and the

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

@@ -0,0 +1,188 @@
+import { ChannelError } from '@noodle-borg/assistant-gateway/portable';
+import { z } from 'zod';
+import { boundedJson, } from './provider.js';
+const phone = z.string().regex(/^\+[1-9]\d{1,14}$/);
+const messageId = z.string().regex(/^(SM|MM)[a-fA-F0-9]{32}$/);
+const numberSchema = z.object({
+    sid: z.string(),
+    account_sid: z.string(),
+    phone_number: phone,
+    capabilities: z.object({ sms: z.boolean() }),
+    sms_url: z.string().nullable(),
+    sms_method: z.string(),
+    sms_application_sid: z.string().nullable(),
+});
+/** Twilio REST transport, contained behind the existing messaging provider port. */
+export class TwilioSms {
+    token;
+    asset;
+    callback;
+    fetcher;
+    constructor(token, asset, callback, fetcher = fetch) {
+        this.token = token;
+        this.asset = asset;
+        this.callback = callback;
+        this.fetcher = fetcher;
+    }
+    request(path, fields) {
+        return this.fetcher(`https://api.twilio.com/2010-04-01/Accounts/${this.asset.accountSid}${path}`, {
+            method: fields ? 'POST' : 'GET',
+            headers: {
+                authorization: `Basic ${Buffer.from(`${this.asset.accountSid}:${this.token}`).toString('base64')}`,
+                ...(fields ? { 'content-type': 'application/x-www-form-urlencoded' } : {}),
+            },
+            ...(fields ? { body: new URLSearchParams(fields).toString() } : {}),
+            redirect: 'error',
+            signal: AbortSignal.timeout(8_000),
+        });
+    }
+    async number() {
+        const response = await this.request(`/IncomingPhoneNumbers/${this.asset.phoneNumberSid}.json`);
+        if (!response.ok) {
+            await response.body?.cancel();
+            throw new ChannelError('provider_unavailable');
+        }
+        const parsed = numberSchema.safeParse(await boundedJson(response));
+        if (!parsed.success)
+            throw new ChannelError('provider_response_invalid');
+        const number = parsed.data;
+        if (number.sid !== this.asset.phoneNumberSid ||
+            number.account_sid !== this.asset.accountSid ||
+            number.phone_number !== this.asset.phoneNumber)
+            throw new ChannelError('asset_mismatch');
+        return number;
+    }
+    async health() {
+        const number = await this.number();
+        const response = await this.request('.json');
+        if (!response.ok) {
+            await response.body?.cancel();
+            throw new ChannelError('provider_unavailable');
+        }
+        const account = z
+            .object({ sid: z.string(), status: z.string() })
+            .safeParse(await boundedJson(response));
+        if (!account.success || account.data.sid !== this.asset.accountSid)
+            throw new ChannelError('asset_mismatch');
+        const canSend = number.capabilities.sms && account.data.status === 'active';
+        return {
+            assetId: number.sid,
+            canSend,
+            status: canSend ? 'AVAILABLE' : 'BLOCKED',
+        };
+    }
+    async inspectWebhook(url) {
+        const number = await this.number();
+        return {
+            matches: number.sms_url === url && number.sms_method === 'POST' && !number.sms_application_sid,
+            authenticated: true,
+        };
+    }
+    async configureWebhook(url) {
+        const number = await this.number();
+        if (number.sms_application_sid ||
+            (number.sms_url &&
+                number.sms_url !== url &&
+                number.sms_url !== 'https://demo.twilio.com/welcome/sms/reply'))
+            throw new ChannelError('webhook_ownership_conflict');
+        const response = await this.request(`/IncomingPhoneNumbers/${this.asset.phoneNumberSid}.json`, {
+            SmsUrl: url,
+            SmsMethod: 'POST',
+        });
+        await response.body?.cancel();
+        if (!response.ok)
+            throw new ChannelError('webhook_configuration_failed');
+    }
+    async setBlocked() {
+        return { state: 'error', code: 'provider_block_unsupported' };
+    }
+    async send(input) {
+        if (input.to.kind !== 'phone' ||
+            !phone.safeParse(input.to.value).success ||
+            !input.text ||
+            input.text.length > 600)
+            return { state: 'failed', code: 'reply_invalid' };
+        try {
+            const response = await this.request('/Messages.json', {
+                From: this.asset.phoneNumber,
+                To: input.to.value,
+                Body: input.text,
+                StatusCallback: `${this.callback}/status`,
+                ValidityPeriod: '300',
+            });
+            if (!response.ok) {
+                await response.body?.cancel();
+                return {
+                    state: response.status >= 500 || response.status === 408 ? 'unknown' : 'failed',
+                    code: `provider_http_${response.status}`,
+                };
+            }
+            const parsed = z.object({ sid: messageId }).safeParse(await boundedJson(response));
+            return parsed.success
+                ? { state: 'accepted', providerMessageId: parsed.data.sid }
+                : { state: 'unknown', code: 'provider_receipt_invalid' };
+        }
+        catch {
+            return { state: 'unknown', code: 'provider_outcome_unknown' };
+        }
+    }
+    /** Twilio callbacks lack a creation timestamp. Read the immutable resource timestamp so retries
+     * deduplicate identically and a signed callback cannot revive a message after retention expires. */
+    async receive(sid) {
+        if (!messageId.safeParse(sid).success)
+            throw new ChannelError('message_invalid');
+        const response = await this.request(`/Messages/${sid}.json`);
+        if (!response.ok) {
+            await response.body?.cancel();
+            throw new ChannelError('provider_unavailable');
+        }
+        const parsed = z
+            .object({
+            sid: messageId,
+            account_sid: z.string(),
+            direction: z.string(),
+            from: phone,
+            to: phone,
+            body: z.string().max(16_384),
+            num_media: z.string(),
+            date_created: z.string(),
+        })
+            .safeParse(await boundedJson(response));
+        if (!parsed.success)
+            throw new ChannelError('provider_response_invalid');
+        const value = parsed.data;
+        if (value.sid !== sid ||
+            value.account_sid !== this.asset.accountSid ||
+            value.to !== this.asset.phoneNumber ||
+            value.direction !== 'inbound')
+            throw new ChannelError('message_asset_mismatch');
+        const eventAt = Date.parse(value.date_created);
+        if (!Number.isSafeInteger(eventAt))
+            throw new ChannelError('timestamp_invalid');
+        const word = value.body.trim().toUpperCase();
+        const control = [
+            'STOP',
+            'STOPALL',
+            'UNSUBSCRIBE',
+            'CANCEL',
+            'END',
+            'QUIT',
+            'REVOKE',
+            'OPTOUT',
+        ].includes(word)
+            ? 'stop'
+            : ['START', 'UNSTOP'].includes(word)
+                ? 'start'
+                : ['HELP', 'INFO'].includes(word)
+                    ? 'help'
+                    : undefined;
+        return {
+            providerId: sid,
+            address: { kind: 'phone', value: value.from },
+            eventAt,
+            ...(value.num_media === '0' && value.body ? { text: value.body } : {}),
+            ...(control ? { control } : {}),
+        };
+    }
+}
+//# sourceMappingURL=twilio-sms.js.map

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

@@ -0,0 +1,16 @@
+import { createHmac, timingSafeEqual } from 'node:crypto';
+/** Twilio's documented form signature: the exact public URL plus every sorted POST parameter.
+ * Duplicate parameters are rejected before this boundary; unknown provider fields stay signed. */
+export function verifyTwilioSignature(url, params, signature, token) {
+    if (typeof signature !== 'string' || !/^[A-Za-z0-9+/]{27}=$/.test(signature))
+        return false;
+    const payload = url +
+        [...params.keys()]
+            .sort()
+            .map((key) => key + params.get(key))
+            .join('');
+    const expected = createHmac('sha1', token).update(payload).digest();
+    const provided = Buffer.from(signature, 'base64');
+    return provided.length === expected.length && timingSafeEqual(provided, expected);
+}
+//# sourceMappingURL=twilio-webhook.js.map

package/node_modules/@noodle-borg/service/dist/conversation-history/contracts.js

@@ -10,6 +10,7 @@ export const ALL_CONVERSATION_SOURCES = {
     signed_in_customers: true,
     whatsapp: true,
     instagram: true,
+    sms: true,
 };
 /**
  * The latest expiry a shorter window allows an item from `at`; Off (0 days) ends every item now. The

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

@@ -59,9 +59,10 @@ export async function projectBusinessChannels(installation, canEdit, base, deps)
     };
     const registered = await deps.registry.getActiveByTenant(tenant);
     const target = registered && (await resolveTargetOrigins(registered));
-    const [whatsapp, instagram] = await Promise.all([
+    const [whatsapp, instagram, sms] = await Promise.all([
         deps.readMessaging?.(tenant, 'whatsapp'),
         deps.readMessaging?.(tenant, 'instagram'),
+        deps.readMessaging?.(tenant, 'sms'),
     ]);
     // Pausing agent channels pauses every messaging channel with them.
     const intake = (view) => installation.intakeActive ? view : { ...view, status: 'paused' };
@@ -74,6 +75,7 @@ export async function projectBusinessChannels(installation, canEdit, base, deps)
             : {}),
         ...(whatsapp ? { whatsapp: intake(whatsapp) } : {}),
         ...(instagram ? { instagram: intake(instagram) } : {}),
+        ...(sms ? { sms: intake(sms) } : {}),
     };
     if (!target?.deploymentId)
         return {

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

@@ -28,6 +28,7 @@ function handleServiceProbe(req, res, url, { tls, moduleHost, buildInfo, options
         applySecurityHeaders(res, tls);
         return sendJson(res, 200, serviceInfoPayload(buildInfo, options.developerMcp === true, {
             whatsapp: whatsapp !== undefined,
+            sms: whatsapp !== undefined,
             instagram: whatsapp?.options.meta !== undefined,
         }));
     }

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

@@ -0,0 +1,66 @@
+import { recordChannelDelivery } from '@noodle-borg/assistant-gateway/portable';
+import { readBodyBuffer, sendJson } from '@noodle-borg/transport-http';
+import { TwilioSms } from '../channels/twilio-sms.js';
+import { verifyTwilioSignature } from '../channels/twilio-webhook.js';
+/** Per-binding routing selects only a credential candidate. Signature, account and number must all
+ * match before a callback may change durable state. The public URL comes from operator config. */
+export async function smsWebhook(req, res, id, status, url, runtime) {
+    if (req.method !== 'POST')
+        return sendJson(res, 405, { error: 'method_not_allowed' });
+    if (url.search ||
+        req.headers['content-type']?.split(';')[0] !== 'application/x-www-form-urlencoded')
+        return sendJson(res, 400, { error: 'webhook_invalid' });
+    const binding = await runtime.channels.internal(id);
+    if (binding.channel !== 'sms')
+        return sendJson(res, 404, { error: 'not_found' });
+    const { adapter, webhookSecret } = await runtime.provider(binding);
+    const body = await readBodyBuffer(req, 65_536);
+    if (!body.ok)
+        return sendJson(res, 413, { error: 'webhook_invalid' });
+    const params = new URLSearchParams(body.buffer.toString('utf8'));
+    if ([...params.keys()].length > 100 ||
+        [...params.keys()].some((key) => params.getAll(key).length !== 1))
+        return sendJson(res, 400, { error: 'webhook_invalid' });
+    const callback = runtime.webhookUrl(req, binding) + (status ? '/status' : '');
+    if (!webhookSecret ||
+        !verifyTwilioSignature(callback, params, req.headers['x-twilio-signature'], webhookSecret))
+        return sendJson(res, 401, { error: 'unauthorized' });
+    if (params.get('AccountSid') !== binding.accountSid ||
+        params.get(status ? 'From' : 'To') !== binding.phoneNumber)
+        return sendJson(res, 400, { error: 'asset_mismatch' });
+    const sid = params.get('MessageSid');
+    if (!sid || !/^(SM|MM)[a-fA-F0-9]{32}$/.test(sid))
+        return sendJson(res, 400, { error: 'message_invalid' });
+    if (status) {
+        const state = params.get('MessageStatus');
+        const delivery = state === 'delivered'
+            ? 'delivered'
+            : state === 'sent'
+                ? 'sent'
+                : state === 'failed' || state === 'undelivered'
+                    ? 'failed'
+                    : undefined;
+        if (delivery)
+            await recordChannelDelivery(runtime.channels.store, id, sid, delivery, runtime.channels.now());
+    }
+    else {
+        if (!(adapter instanceof TwilioSms))
+            return sendJson(res, 503, { error: 'provider_unavailable' });
+        const message = await adapter.receive(sid);
+        if (message.address.value !== params.get('From'))
+            return sendJson(res, 400, { error: 'asset_mismatch' });
+        const optOut = params.get('OptOutType');
+        const control = optOut === 'STOP'
+            ? 'stop'
+            : optOut === 'START'
+                ? 'start'
+                : optOut === 'HELP'
+                    ? 'help'
+                    : message.control;
+        await runtime.channels.receive(id, [{ ...message, ...(control ? { control } : {}) }], await runtime.retention(binding));
+    }
+    res.writeHead(200, { 'content-type': 'text/xml; charset=utf-8' });
+    res.end('<Response/>');
+    runtime.options.worker.wake();
+}
+//# sourceMappingURL=sms-twilio.js.map

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

@@ -6,6 +6,7 @@ import { INSTAGRAM_META_CALLBACK_PATH } from '../channels/instagram-meta.js';
 import { WHATSAPP_META_CALLBACK_PATH } from '../channels/meta-cloud.js';
 import { authorizeTenantControl, developerGrantRouteAccess } from './control-plane.js';
 import { instagramWebhook } from './instagram-meta.js';
+import { smsWebhook } from './sms-twilio.js';
 import { metaWebhook } from './whatsapp-meta.js';
 const participant = /^p_[a-f0-9]{64}$/;
 const eventId = /^e_[0-9_]+$/;
@@ -35,30 +36,33 @@ async function body(req, schema) {
 }
 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|instagram)(?:\/(.*))?$/.exec(url.pathname);
+    const operator = /^\/v1\/orgs\/([^/]+)\/apps\/([^/]+)\/envs\/([^/]+)\/channels\/(whatsapp|instagram|sms)(?:\/(.*))?$/.exec(url.pathname);
+    const sms = /^\/v1\/channels\/sms\/webhooks\/([a-z0-9-]+)(\/status)?$/.exec(url.pathname);
     const meta = url.pathname === WHATSAPP_META_CALLBACK_PATH;
     const instagram = url.pathname === INSTAGRAM_META_CALLBACK_PATH;
-    if (!callback && !operator && !meta && !instagram)
+    if (!callback && !operator && !meta && !instagram && !sms)
         return false;
     res.setHeader('Cache-Control', 'no-store');
     if (!runtime) {
         sendJson(res, 503, {
-            error: 'WhatsApp is unavailable on this service',
-            code: 'whatsapp_unavailable',
+            error: 'Messaging is unavailable on this service',
+            code: 'channel_unavailable',
         });
         return true;
     }
-    const run = Promise.resolve().then(() => meta
-        ? metaWebhook(req, res, url, runtime)
-        : instagram
-            ? instagramWebhook(req, res, url, runtime)
-            : 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], operator[5] ?? '', runtime, grants));
+    const run = Promise.resolve().then(() => sms
+        ? smsWebhook(req, res, sms[1], !!sms[2], url, runtime)
+        : meta
+            ? metaWebhook(req, res, url, runtime)
+            : instagram
+                ? instagramWebhook(req, res, url, runtime)
+                : 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], operator[5] ?? '', runtime, grants));
     void run.catch((error) => {
         const code = error instanceof ChannelError ? error.code : 'channel_unavailable';
         const status = code === 'channel_not_found'
@@ -71,7 +75,7 @@ export function dispatchWhatsAppRoutes(req, res, url, runtime, grants) {
                 'deployment_changed',
             ].includes(code)
                 ? 409
-                : code === 'channel_unavailable' || code === 'ingress_capacity'
+                : ['channel_unavailable', 'ingress_capacity', 'provider_unavailable'].includes(code)
                     ? 503
                     : 400;
         if (!res.headersSent)
@@ -118,9 +122,11 @@ async function operate(req, res, url, tenant, channel, path, runtime, grants) {
     const idempotency = typeof key === 'string' ? key : '';
     const visible = await channels.get(tenant, channel);
     // Every other operation's shape is channel-neutral; the binding and its configuration are not.
-    const bindingSchema = channel === 'instagram'
-        ? wire.InstagramBindingResponseSchema
-        : wire.WhatsAppBindingResponseSchema;
+    const bindingSchema = channel === 'sms'
+        ? wire.SmsBindingResponseSchema
+        : channel === 'instagram'
+            ? wire.InstagramBindingResponseSchema
+            : wire.WhatsAppBindingResponseSchema;
     const audit = async (action) => deps.audit.emit({
         eventType: `assistant.channel.${action}`,
         ...tenant,
@@ -136,7 +142,11 @@ async function operate(req, res, url, tenant, channel, path, runtime, grants) {
             throw new ChannelError('deployment_missing');
         const deploymentId = target.deploymentId;
         let configured;
-        if (channel === 'instagram') {
+        if (channel === 'sms') {
+            const { expectedRevision, ...configuration } = await body(req, wire.SmsConfigureRequestSchema);
+            configured = await channels.configure({ ...configuration, channel, tenant, deploymentId }, identity.subject, idempotency, expectedRevision);
+        }
+        else if (channel === 'instagram') {
             const { expectedRevision, ...configuration } = await body(req, wire.InstagramConfigureRequestSchema);
             configured = await channels.configure({ ...configuration, channel, tenant, deploymentId }, identity.subject, idempotency, expectedRevision);
         }
@@ -198,7 +208,7 @@ async function operate(req, res, url, tenant, channel, path, runtime, grants) {
         const participantId = 'phone' in parsed && parsed.phone
             ? channelParticipantId(await channels.internal(id), {
                 kind: 'phone',
-                value: parsed.phone.slice(1),
+                value: channel === 'sms' ? parsed.phone : parsed.phone.slice(1),
             })
             : parsed.participantId;
         await channels.block(id, participantId, identity.subject, idempotency, parsed.until);

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

@@ -66,6 +66,8 @@ export async function serveLocalService(options = {}) {
     });
     const handler = createServiceHandler(registry, {
         capabilities,
+        // Loopback only (checked above): the one anonymous caller is the author running `noodle dev`.
+        mcpAnonymousCallers: 'author',
         deployGate: {
             authorize: () => ({
                 ok: true,

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

@@ -107,6 +107,7 @@ export function createServiceHandler(registry, options = {}) {
         logger,
         tls,
         protocolMode: options.mcpProtocolMode ?? 'dual',
+        ...(options.mcpAnonymousCallers ? { anonymousCallers: options.mcpAnonymousCallers } : {}),
         ...(options.mcpRequestState === undefined ? {} : { requestState: options.mcpRequestState }),
         ...(options.mcpConfirmationNonceLedger === undefined
             ? {}
@@ -199,7 +200,7 @@ export function createServiceHandler(registry, options = {}) {
         logger,
         conversationPolicy,
     });
-    const whatsapp = createWhatsAppRuntime(options.whatsapp, assistantDeps, {
+    const whatsapp = createWhatsAppRuntime(options, assistantDeps, {
         allowance: moduleHost.resolveActivityHistoryAllowance,
         installations: businessInformationStore,
         activity,
@@ -356,7 +357,7 @@ export function createServiceHandler(registry, options = {}) {
             })) {
             return;
         }
-        if (/\/channels\/(whatsapp|instagram)(\/|$)/.test(url.pathname)) {
+        if (/\/channels\/(whatsapp|instagram|sms)(\/|$)/.test(url.pathname)) {
             applySecurityHeaders(res, tls);
             if (enforceHttps(req, res, tls))
                 return;

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

@@ -41,7 +41,7 @@
     "@noodle-borg/managed-capabilities": "0.0.0",
     "@modelcontextprotocol/sdk": "^1.29.0",
     "@noodle-borg/admission-limits": "0.0.0",
-    "@noodle-borg/agent-kit": "0.110.0",
+    "@noodle-borg/agent-kit": "0.112.0",
     "@noodle-borg/app-package": "0.0.0",
     "@noodle-borg/assistant-gateway": "0.0.0",
     "@noodle-borg/auth": "0.0.0",

package/node_modules/@noodle-borg/transport-http/dist/handler.d.ts

@@ -46,6 +46,11 @@ export interface HttpHandlerOptions {
     readonly authorizeDataPlaneIdentity?: DataPlaneIdentityAuthorizer;
     /** Request admission hook after authentication and JSON parsing, before SDK execution. */
     readonly admissionGate?: AdmissionGate;
+    /**
+     * `author`: every anonymous caller is the app's own author, as on the loopback `noodle dev` service, so
+     * tools that change something run without sign-in. Hosted services never set it.
+     */
+    readonly anonymousCallers?: 'author';
     /** Enqueue one scalar-only analytics event after the response is written. */
     readonly captureRequestEvent?: (event: RequestEventInput) => void;
     /** Separate, best-effort operator intent stream. Requires `intentCaptureMode: starter-v1`. */

package/node_modules/@noodle-borg/transport-http/dist/handler.js

@@ -37,6 +37,7 @@ export function createMcpHttpHandler(target, options = {}) {
             authentication: resolveTargetAuthentication({}, options.verifyOwnerToken),
             authorizeDataPlaneIdentity: options.authorizeDataPlaneIdentity,
             admissionGate: options.admissionGate,
+            anonymousCallers: options.anonymousCallers,
             captureRequestEvent: options.captureRequestEvent,
             captureIntentEvent: options.captureIntentEvent,
             intentCaptureMode: options.intentCaptureMode ?? 'off',
@@ -105,6 +106,7 @@ export function createMcpRouter(lookup, options = {}) {
                 authentication: resolveTargetAuthentication(resolvedTarget, options.verifyOwnerToken),
                 authorizeDataPlaneIdentity: options.authorizeDataPlaneIdentity,
                 admissionGate: options.admissionGate,
+                anonymousCallers: options.anonymousCallers,
                 captureRequestEvent: options.captureRequestEvent,
                 captureIntentEvent: options.captureIntentEvent,
                 intentCaptureMode: resolvedTarget.intentCaptureMode ?? 'off',

package/node_modules/@noodle-borg/transport-http/dist/serve-request.js

@@ -159,7 +159,9 @@ export async function serveRequest(req, res, target, auth, routeId, maxBody, all
             return denied(`admission_denied.${boundedReason(decision.reason)}`, parsed);
         }
     }
-    const authorization = preflightToolAuthorization(parsed, target, protocolContext.caller);
+    const authorization = preflightToolAuthorization(parsed, target, protocolContext.caller, 
+    // On the loopback author loop the anonymous caller is the author, so no public-write rule applies.
+    auth.anonymousCallers === 'author' ? undefined : auth.accessMode);
     for (const observation of authorization.observations) {
         logger.info('mcp.tool_authorization', {
             toolName: observation.toolName,