experimental-ash 0.26.0 → 0.27.0

package/dist/src/public/channels/twilio/inbound.js

@@ -1,123 +1,2 @@
-/**
- * Twilio inbound webhook parsing and prompt shaping.
- *
- * The channel owns these small data shapes instead of exposing raw
- * Twilio webhook payloads as the public API surface.
- */
-const TWILIO_SMS_RESPONSE_INSTRUCTIONS = "Reply for SMS in plain text. Keep the response concise and avoid Markdown formatting, " +
-    "tables, headings, code fences, and long lists. Ask at most one short follow-up question " +
-    "when more information is needed.";
-/** Parses Twilio's incoming-message webhook fields. */
-export function parseTwilioTextMessage(params) {
-    const from = requiredParam(params, "From");
-    const body = requiredParam(params, "Body");
-    if (!from || !body)
-        return null;
-    return {
-        accountSid: optionalParam(params, "AccountSid"),
-        body,
-        from,
-        messageSid: optionalParam(params, "MessageSid") ?? optionalParam(params, "SmsMessageSid"),
-        raw: params,
-        to: optionalParam(params, "To"),
-    };
-}
-/** Parses Twilio's incoming-call webhook fields. */
-export function parseTwilioVoiceCall(params) {
-    const from = requiredParam(params, "From") ?? requiredParam(params, "Caller");
-    if (!from)
-        return null;
-    return {
-        accountSid: optionalParam(params, "AccountSid"),
-        callSid: optionalParam(params, "CallSid"),
-        from,
-        raw: params,
-        to: optionalParam(params, "To") ?? optionalParam(params, "Called"),
-    };
-}
-/**
- * Parses Twilio voice transcription fields.
- *
- * Supports `<Gather input="speech">` (`SpeechResult`), recording
- * transcription callbacks (`TranscriptionText`), and real-time
- * transcription callbacks (`TranscriptionData` JSON). Real-time partial
- * results are ignored until Twilio marks them final.
- */
-export function parseTwilioVoiceTranscription(params) {
-    const from = requiredParam(params, "From") ?? requiredParam(params, "Caller");
-    if (!from)
-        return null;
-    const parsedData = parseTranscriptionData(optionalParam(params, "TranscriptionData"));
-    const final = optionalParam(params, "Final");
-    if (final === "false")
-        return null;
-    const text = optionalParam(params, "SpeechResult") ??
-        optionalParam(params, "TranscriptionText") ??
-        parsedData?.transcript ??
-        "";
-    if (!text.trim())
-        return null;
-    return {
-        callSid: optionalParam(params, "CallSid"),
-        confidence: parseConfidence(optionalParam(params, "Confidence") ?? parsedData?.confidence),
-        from,
-        raw: params,
-        text,
-        to: optionalParam(params, "To") ?? optionalParam(params, "Called"),
-        transcriptionSid: optionalParam(params, "TranscriptionSid"),
-    };
-}
-/** Renders a deterministic `<twilio_context>` block for the model. */
-export function formatTwilioContextBlock(context) {
-    const lines = [
-        "<twilio_context>",
-        `channel: ${context.channel}`,
-        "response_medium: sms",
-        `response_instructions: ${TWILIO_SMS_RESPONSE_INSTRUCTIONS}`,
-        `from: ${context.from}`,
-        ...(context.to ? [`to: ${context.to}`] : []),
-        ...(context.messageSid ? [`message_sid: ${context.messageSid}`] : []),
-        ...(context.callSid ? [`call_sid: ${context.callSid}`] : []),
-        "</twilio_context>",
-    ];
-    return lines.join("\n");
-}
-/** Prepends a `<twilio_context>` block to the inbound turn message. */
-export function prependTwilioContext(message, context) {
-    const block = formatTwilioContextBlock(context);
-    if (typeof message === "string") {
-        return message.length > 0 ? `${block}\n\n${message}` : block;
-    }
-    const contextPart = { type: "text", text: block };
-    return [contextPart, ...message];
-}
-function requiredParam(params, name) {
-    const value = params.get(name);
-    return value && value.trim().length > 0 ? value : null;
-}
-function optionalParam(params, name) {
-    const value = params.get(name);
-    return value === null || value.length === 0 ? undefined : value;
-}
-function parseTranscriptionData(value) {
-    if (!value)
-        return null;
-    try {
-        const parsed = JSON.parse(value);
-        return {
-            confidence: typeof parsed.confidence === "number" || typeof parsed.confidence === "string"
-                ? String(parsed.confidence)
-                : undefined,
-            transcript: typeof parsed.transcript === "string" ? parsed.transcript : undefined,
-        };
-    }
-    catch {
-        return null;
-    }
-}
-function parseConfidence(value) {
-    if (value === undefined)
-        return undefined;
-    const parsed = Number(value);
-    return Number.isFinite(parsed) ? parsed : undefined;
-}
+var TWILIO_SMS_RESPONSE_INSTRUCTIONS=`Reply for SMS in plain text. Keep the response concise and avoid Markdown formatting, tables, headings, code fences, and long lists. Ask at most one short follow-up question when more information is needed.`;function parseTwilioTextMessage(e){let t=requiredParam(e,`From`),n=requiredParam(e,`Body`);return!t||!n?null:{accountSid:optionalParam(e,`AccountSid`),body:n,from:t,messageSid:optionalParam(e,`MessageSid`)??optionalParam(e,`SmsMessageSid`),raw:e,to:optionalParam(e,`To`)}}function parseTwilioVoiceCall(e){let t=requiredParam(e,`From`)??requiredParam(e,`Caller`);return t?{accountSid:optionalParam(e,`AccountSid`),callSid:optionalParam(e,`CallSid`),from:t,raw:e,to:optionalParam(e,`To`)??optionalParam(e,`Called`)}:null}function parseTwilioVoiceTranscription(e){let t=requiredParam(e,`From`)??requiredParam(e,`Caller`);if(!t)return null;let n=parseTranscriptionData(optionalParam(e,`TranscriptionData`));if(optionalParam(e,`Final`)===`false`)return null;let r=optionalParam(e,`SpeechResult`)??optionalParam(e,`TranscriptionText`)??n?.transcript??``;return r.trim()?{callSid:optionalParam(e,`CallSid`),confidence:parseConfidence(optionalParam(e,`Confidence`)??n?.confidence),from:t,raw:e,text:r,to:optionalParam(e,`To`)??optionalParam(e,`Called`),transcriptionSid:optionalParam(e,`TranscriptionSid`)}:null}function formatTwilioContextBlock(t){return[`<twilio_context>`,`channel: ${t.channel}`,`response_medium: sms`,`response_instructions: ${TWILIO_SMS_RESPONSE_INSTRUCTIONS}`,`from: ${t.from}`,...t.to?[`to: ${t.to}`]:[],...t.messageSid?[`message_sid: ${t.messageSid}`]:[],...t.callSid?[`call_sid: ${t.callSid}`]:[],`</twilio_context>`].join(`
+`)}function prependTwilioContext(e,t){let n=formatTwilioContextBlock(t);return typeof e==`string`?e.length>0?`${n}\n\n${e}`:n:[{type:`text`,text:n},...e]}function requiredParam(e,t){let n=e.get(t);return n&&n.trim().length>0?n:null}function optionalParam(e,t){let n=e.get(t);return n===null||n.length===0?void 0:n}function parseTranscriptionData(e){if(!e)return null;try{let t=JSON.parse(e);return{confidence:typeof t.confidence==`number`||typeof t.confidence==`string`?String(t.confidence):void 0,transcript:typeof t.transcript==`string`?t.transcript:void 0}}catch{return null}}function parseConfidence(e){if(e===void 0)return;let t=Number(e);return Number.isFinite(t)?t:void 0}export{formatTwilioContextBlock,parseTwilioTextMessage,parseTwilioVoiceCall,parseTwilioVoiceTranscription,prependTwilioContext};

package/dist/src/public/channels/twilio/index.js

@@ -1,4 +1 @@
-export { twilioChannel, } from "#public/channels/twilio/twilioChannel.js";
-export { callTwilioApi, resolveTwilioAccountSid, sendTwilioMessage, twilioContinuationToken, updateTwilioCall, } from "#public/channels/twilio/api.js";
-export { emptyTwilioResponse, escapeXml, gatherSpeechTwilioResponse, sayTwilioResponse, twimlResponse, } from "#public/channels/twilio/twiml.js";
-export { buildTwilioSignatureBase, resolveTwilioAuthToken, signTwilioRequest, verifyTwilioRequest, } from "#public/channels/twilio/verify.js";
+import{buildTwilioSignatureBase,resolveTwilioAuthToken,signTwilioRequest,verifyTwilioRequest}from"#public/channels/twilio/verify.js";import{twilioChannel}from"#public/channels/twilio/twilioChannel.js";import{callTwilioApi,resolveTwilioAccountSid,sendTwilioMessage,twilioContinuationToken,updateTwilioCall}from"#public/channels/twilio/api.js";import{emptyTwilioResponse,escapeXml,gatherSpeechTwilioResponse,sayTwilioResponse,twimlResponse}from"#public/channels/twilio/twiml.js";export{buildTwilioSignatureBase,callTwilioApi,emptyTwilioResponse,escapeXml,gatherSpeechTwilioResponse,resolveTwilioAccountSid,resolveTwilioAuthToken,sayTwilioResponse,sendTwilioMessage,signTwilioRequest,twilioChannel,twilioContinuationToken,twimlResponse,updateTwilioCall,verifyTwilioRequest};

package/dist/src/public/channels/twilio/twilioChannel.js

@@ -1,316 +1 @@
-import { createLogger } from "#internal/logging.js";
-import { callTwilioApi, sendTwilioMessage, twilioContinuationToken, updateTwilioCall, } from "#public/channels/twilio/api.js";
-import { defaultEvents, defaultOnText, defaultOnVoice, defaultOnVoiceTranscription, } from "#public/channels/twilio/defaults.js";
-import { parseTwilioTextMessage, parseTwilioVoiceCall, parseTwilioVoiceTranscription, prependTwilioContext, } from "#public/channels/twilio/inbound.js";
-import { emptyTwilioResponse, gatherSpeechTwilioResponse, sayTwilioResponse, } from "#public/channels/twilio/twiml.js";
-import { verifyTwilioRequest, } from "#public/channels/twilio/verify.js";
-import { defineChannel, POST, } from "#public/definitions/defineChannel.js";
-const log = createLogger("twilio.channel");
-/** Twilio channel factory for SMS and speech-transcribed inbound calls. */
-export function twilioChannel(config) {
-    assertAllowFromConfigured(config);
-    const routes = buildRoutes(config.route ?? "/ash/v1/twilio");
-    const onText = config.onText ?? defaultOnText;
-    const onVoice = config.onVoice ?? defaultOnVoice;
-    const onVoiceTranscription = config.onVoiceTranscription ?? defaultOnVoiceTranscription;
-    const mergedEvents = { ...defaultEvents, ...config.events };
-    return defineChannel({
-        kindHint: "twilio",
-        state: {
-            from: null,
-            to: null,
-            lastCallSid: null,
-            lastMessageSid: null,
-        },
-        context(state, session) {
-            return rebuildTwilioContext(state, session, config);
-        },
-        routes: [
-            POST(routes.messages, async (req, { send, waitUntil }) => {
-                const verified = await verifyInbound(req, config);
-                if (verified === null)
-                    return new Response("unauthorized", { status: 401 });
-                const message = parseTwilioTextMessage(verified.params);
-                if (!message)
-                    return emptyTwilioResponse();
-                if (!(await isAllowed(message.from, config.allowFrom)))
-                    return new Response("forbidden", { status: 403 });
-                waitUntil(dispatchText({ config, message, onText, send }));
-                return emptyTwilioResponse();
-            }),
-            POST(routes.voice, async (req) => {
-                const verified = await verifyInbound(req, config);
-                if (verified === null)
-                    return new Response("unauthorized", { status: 401 });
-                const call = parseTwilioVoiceCall(verified.params);
-                if (!call)
-                    return sayTwilioResponse("Missing caller information.");
-                if (!(await isAllowed(call.from, config.allowFrom)))
-                    return new Response("forbidden", { status: 403 });
-                const voiceResult = await acceptVoiceCall({
-                    call,
-                    config,
-                    onVoice,
-                });
-                if (voiceResult === null)
-                    return new Response("forbidden", { status: 403 });
-                const voiceOptions = voiceResult ?? {};
-                return gatherSpeechTwilioResponse({
-                    actionUrl: await buildActionUrl(req, config, routes.transcription),
-                    hints: voiceOptions.hints ?? config.voice?.hints,
-                    language: voiceOptions.language ?? config.voice?.language,
-                    profanityFilter: voiceOptions.profanityFilter ?? config.voice?.profanityFilter,
-                    prompt: voiceOptions.prompt ??
-                        config.voice?.prompt ??
-                        "Please say your message after the tone.",
-                    speechModel: voiceOptions.speechModel ?? config.voice?.speechModel,
-                    speechTimeout: voiceOptions.speechTimeout ?? config.voice?.speechTimeout ?? "auto",
-                    timeoutSeconds: voiceOptions.timeoutSeconds ?? config.voice?.timeoutSeconds,
-                    voice: voiceOptions.voice ?? config.voice?.voice,
-                });
-            }),
-            POST(routes.transcription, async (req, { send, waitUntil }) => {
-                const verified = await verifyInbound(req, config);
-                if (verified === null)
-                    return new Response("unauthorized", { status: 401 });
-                const transcription = parseTwilioVoiceTranscription(verified.params);
-                if (!transcription) {
-                    return gatherSpeechTwilioResponse({
-                        actionUrl: await buildActionUrl(req, config, routes.transcription),
-                        language: config.voice?.language,
-                        prompt: config.voice?.prompt ?? "Please say your message after the tone.",
-                        speechTimeout: config.voice?.speechTimeout ?? "auto",
-                        timeoutSeconds: config.voice?.timeoutSeconds,
-                    });
-                }
-                if (!(await isAllowed(transcription.from, config.allowFrom))) {
-                    return new Response("forbidden", { status: 403 });
-                }
-                waitUntil(dispatchVoiceTranscription({ config, onVoiceTranscription, send, transcription }));
-                return sayTwilioResponse(config.voice?.acknowledgement ?? "Thanks. I'll follow up by text.");
-            }),
-        ],
-        async receive(input, { send }) {
-            const phoneNumber = readString(input.args.phoneNumber);
-            if (!phoneNumber) {
-                throw new Error("twilioChannel().receive requires args.phoneNumber.");
-            }
-            const from = readString(input.args.from) ?? config.messaging?.from ?? null;
-            return send(input.message, {
-                auth: input.auth,
-                continuationToken: twilioContinuationToken(phoneNumber, from ?? undefined),
-                state: {
-                    from: phoneNumber,
-                    lastCallSid: null,
-                    lastMessageSid: null,
-                    to: from,
-                },
-            });
-        },
-        events: mergedEvents,
-    });
-}
-function rebuildTwilioContext(state, session, config) {
-    return {
-        session,
-        state,
-        twilio: buildTwilioHandle({
-            callSid: state.lastCallSid ?? undefined,
-            config,
-            from: state.from ?? "",
-            to: state.to ?? undefined,
-        }),
-    };
-}
-function buildTwilioHandle(input) {
-    const api = input.config.api;
-    const credentials = input.config.credentials;
-    const defaultFrom = input.config.messaging?.from ?? input.to;
-    const defaultMessagingServiceSid = input.config.messaging?.messagingServiceSid;
-    const defaultStatusCallbackUrl = input.config.messaging?.statusCallbackUrl;
-    return {
-        callSid: input.callSid,
-        from: input.from,
-        to: input.to,
-        request(path, body) {
-            return callTwilioApi({
-                apiBaseUrl: api?.apiBaseUrl,
-                body,
-                credentials,
-                fetch: api?.fetch,
-                path,
-            });
-        },
-        sendMessage(message, options) {
-            return sendTwilioMessage({
-                apiBaseUrl: api?.apiBaseUrl,
-                body: message,
-                credentials,
-                fetch: api?.fetch,
-                from: options?.from ?? defaultFrom,
-                messagingServiceSid: options?.messagingServiceSid ?? defaultMessagingServiceSid,
-                statusCallbackUrl: options?.statusCallbackUrl ?? defaultStatusCallbackUrl,
-                to: options?.to ?? input.from,
-            });
-        },
-        updateCall(callSid, twiml) {
-            return updateTwilioCall({
-                apiBaseUrl: api?.apiBaseUrl,
-                callSid,
-                credentials,
-                fetch: api?.fetch,
-                twiml,
-            });
-        },
-    };
-}
-function buildRoutes(baseRoute) {
-    const base = baseRoute.endsWith("/") ? baseRoute.slice(0, -1) : baseRoute;
-    return {
-        messages: `${base}/messages`,
-        transcription: `${base}/voice/transcription`,
-        voice: `${base}/voice`,
-    };
-}
-function assertAllowFromConfigured(config) {
-    if (config?.allowFrom === undefined) {
-        throw new Error('twilioChannel requires allowFrom. Use allowFrom: "*" to allow all numbers.');
-    }
-}
-async function verifyInbound(req, config) {
-    try {
-        return await verifyTwilioRequest(req, {
-            authToken: config.credentials?.authToken,
-            webhookUrl: config.webhookUrl,
-        });
-    }
-    catch (error) {
-        log.warn("twilio inbound verification failed", { error });
-        return null;
-    }
-}
-async function dispatchText(input) {
-    const { message } = input;
-    const twilio = {
-        twilio: buildTwilioHandle({
-            callSid: undefined,
-            config: input.config,
-            from: message.from,
-            to: message.to,
-        }),
-    };
-    let result;
-    try {
-        result = await input.onText(twilio, message);
-    }
-    catch (error) {
-        log.error("text handler failed", { error });
-        return;
-    }
-    if (result === null || result === undefined)
-        return;
-    const turnMessage = prependTwilioContext(message.body, {
-        channel: "text",
-        from: message.from,
-        messageSid: message.messageSid,
-        to: message.to,
-    });
-    try {
-        await input.send(turnMessage, {
-            auth: result.auth,
-            continuationToken: twilioContinuationToken(message.from, message.to),
-            state: {
-                from: message.from,
-                lastCallSid: null,
-                lastMessageSid: message.messageSid ?? null,
-                to: message.to ?? null,
-            },
-        });
-    }
-    catch (error) {
-        log.error("text delivery failed", { error });
-    }
-}
-async function acceptVoiceCall(input) {
-    const { call } = input;
-    const twilio = {
-        twilio: buildTwilioHandle({
-            callSid: call.callSid,
-            config: input.config,
-            from: call.from,
-            to: call.to,
-        }),
-    };
-    try {
-        return await input.onVoice(twilio, call);
-    }
-    catch (error) {
-        log.error("voice handler failed", { error });
-        return null;
-    }
-}
-async function dispatchVoiceTranscription(input) {
-    const { transcription } = input;
-    const twilio = {
-        twilio: buildTwilioHandle({
-            callSid: transcription.callSid,
-            config: input.config,
-            from: transcription.from,
-            to: transcription.to,
-        }),
-    };
-    let result;
-    try {
-        result = await input.onVoiceTranscription(twilio, transcription);
-    }
-    catch (error) {
-        log.error("voice transcription handler failed", { error });
-        return;
-    }
-    if (result === null || result === undefined)
-        return;
-    const turnMessage = prependTwilioContext(transcription.text, {
-        callSid: transcription.callSid,
-        channel: "voice",
-        from: transcription.from,
-        to: transcription.to,
-    });
-    try {
-        await input.send(turnMessage, {
-            auth: result.auth,
-            continuationToken: twilioContinuationToken(transcription.from, transcription.to),
-            state: {
-                from: transcription.from,
-                lastCallSid: transcription.callSid ?? null,
-                lastMessageSid: null,
-                to: transcription.to ?? null,
-            },
-        });
-    }
-    catch (error) {
-        log.error("voice transcription delivery failed", { error });
-    }
-}
-async function isAllowed(from, allowFrom) {
-    const resolved = typeof allowFrom === "function" ? await allowFrom() : allowFrom;
-    if (resolved === "*")
-        return true;
-    return typeof resolved === "string" ? resolved === from : resolved.includes(from);
-}
-async function buildActionUrl(request, config, route) {
-    const base = typeof config.publicBaseUrl === "function"
-        ? await config.publicBaseUrl(request)
-        : config.publicBaseUrl;
-    if (base)
-        return new URL(route, ensureTrailingSlash(base)).toString();
-    const url = new URL(request.url);
-    url.pathname = route;
-    url.search = "";
-    return url.toString();
-}
-function ensureTrailingSlash(value) {
-    return value.endsWith("/") ? value : `${value}/`;
-}
-function readString(value) {
-    return typeof value === "string" && value.length > 0 ? value : undefined;
-}
+import{createLogger}from"#internal/logging.js";import{POST,defineChannel}from"#public/definitions/defineChannel.js";import{verifyTwilioRequest}from"#public/channels/twilio/verify.js";import{callTwilioApi,sendTwilioMessage,twilioContinuationToken,updateTwilioCall}from"#public/channels/twilio/api.js";import{emptyTwilioResponse,gatherSpeechTwilioResponse,sayTwilioResponse}from"#public/channels/twilio/twiml.js";import{defaultEvents,defaultOnText,defaultOnVoice,defaultOnVoiceTranscription}from"#public/channels/twilio/defaults.js";import{parseTwilioTextMessage,parseTwilioVoiceCall,parseTwilioVoiceTranscription,prependTwilioContext}from"#public/channels/twilio/inbound.js";var log=createLogger(`twilio.channel`);function twilioChannel(e){assertAllowFromConfigured(e);let r=buildRoutes(e.route??`/ash/v1/twilio`),i=e.onText??defaultOnText,a=e.onVoice??defaultOnVoice,s=e.onVoiceTranscription??defaultOnVoiceTranscription,l={...defaultEvents,...e.events};return defineChannel({kindHint:`twilio`,state:{from:null,to:null,lastCallSid:null,lastMessageSid:null},context(t,n){return rebuildTwilioContext(t,n,e)},routes:[POST(r.messages,async(t,{send:n,waitUntil:r})=>{let a=await verifyInbound(t,e);if(a===null)return new Response(`unauthorized`,{status:401});let o=parseTwilioTextMessage(a.params);return o?await isAllowed(o.from,e.allowFrom)?(r(dispatchText({config:e,message:o,onText:i,send:n})),emptyTwilioResponse()):new Response(`forbidden`,{status:403}):emptyTwilioResponse()}),POST(r.voice,async t=>{let n=await verifyInbound(t,e);if(n===null)return new Response(`unauthorized`,{status:401});let i=parseTwilioVoiceCall(n.params);if(!i)return sayTwilioResponse(`Missing caller information.`);if(!await isAllowed(i.from,e.allowFrom))return new Response(`forbidden`,{status:403});let o=await acceptVoiceCall({call:i,config:e,onVoice:a});if(o===null)return new Response(`forbidden`,{status:403});let s=o??{};return gatherSpeechTwilioResponse({actionUrl:await buildActionUrl(t,e,r.transcription),hints:s.hints??e.voice?.hints,language:s.language??e.voice?.language,profanityFilter:s.profanityFilter??e.voice?.profanityFilter,prompt:s.prompt??e.voice?.prompt??`Please say your message after the tone.`,speechModel:s.speechModel??e.voice?.speechModel,speechTimeout:s.speechTimeout??e.voice?.speechTimeout??`auto`,timeoutSeconds:s.timeoutSeconds??e.voice?.timeoutSeconds,voice:s.voice??e.voice?.voice})}),POST(r.transcription,async(t,{send:n,waitUntil:i})=>{let a=await verifyInbound(t,e);if(a===null)return new Response(`unauthorized`,{status:401});let o=parseTwilioVoiceTranscription(a.params);return o?await isAllowed(o.from,e.allowFrom)?(i(dispatchVoiceTranscription({config:e,onVoiceTranscription:s,send:n,transcription:o})),sayTwilioResponse(e.voice?.acknowledgement??`Thanks. I'll follow up by text.`)):new Response(`forbidden`,{status:403}):gatherSpeechTwilioResponse({actionUrl:await buildActionUrl(t,e,r.transcription),language:e.voice?.language,prompt:e.voice?.prompt??`Please say your message after the tone.`,speechTimeout:e.voice?.speechTimeout??`auto`,timeoutSeconds:e.voice?.timeoutSeconds})})],async receive(t,{send:n}){let r=readString(t.args.phoneNumber);if(!r)throw Error(`twilioChannel().receive requires args.phoneNumber.`);let i=readString(t.args.from)??e.messaging?.from??null;return n(t.message,{auth:t.auth,continuationToken:twilioContinuationToken(r,i??void 0),state:{from:r,lastCallSid:null,lastMessageSid:null,to:i}})},events:l})}function rebuildTwilioContext(e,t,n){return{session:t,state:e,twilio:buildTwilioHandle({callSid:e.lastCallSid??void 0,config:n,from:e.from??``,to:e.to??void 0})}}function buildTwilioHandle(e){let t=e.config.api,n=e.config.credentials,r=e.config.messaging?.from??e.to,o=e.config.messaging?.messagingServiceSid,c=e.config.messaging?.statusCallbackUrl;return{callSid:e.callSid,from:e.from,to:e.to,request(e,r){return callTwilioApi({apiBaseUrl:t?.apiBaseUrl,body:r,credentials:n,fetch:t?.fetch,path:e})},sendMessage(i,s){return sendTwilioMessage({apiBaseUrl:t?.apiBaseUrl,body:i,credentials:n,fetch:t?.fetch,from:s?.from??r,messagingServiceSid:s?.messagingServiceSid??o,statusCallbackUrl:s?.statusCallbackUrl??c,to:s?.to??e.from})},updateCall(e,r){return updateTwilioCall({apiBaseUrl:t?.apiBaseUrl,callSid:e,credentials:n,fetch:t?.fetch,twiml:r})}}}function buildRoutes(e){let t=e.endsWith(`/`)?e.slice(0,-1):e;return{messages:`${t}/messages`,transcription:`${t}/voice/transcription`,voice:`${t}/voice`}}function assertAllowFromConfigured(e){if(e?.allowFrom===void 0)throw Error(`twilioChannel requires allowFrom. Use allowFrom: "*" to allow all numbers.`)}async function verifyInbound(e,t){try{return await verifyTwilioRequest(e,{authToken:t.credentials?.authToken,webhookUrl:t.webhookUrl})}catch(e){return log.warn(`twilio inbound verification failed`,{error:e}),null}}async function dispatchText(e){let{message:t}=e,n={twilio:buildTwilioHandle({callSid:void 0,config:e.config,from:t.from,to:t.to})},r;try{r=await e.onText(n,t)}catch(e){log.error(`text handler failed`,{error:e});return}if(r==null)return;let i=prependTwilioContext(t.body,{channel:`text`,from:t.from,messageSid:t.messageSid,to:t.to});try{await e.send(i,{auth:r.auth,continuationToken:twilioContinuationToken(t.from,t.to),state:{from:t.from,lastCallSid:null,lastMessageSid:t.messageSid??null,to:t.to??null}})}catch(e){log.error(`text delivery failed`,{error:e})}}async function acceptVoiceCall(e){let{call:t}=e,n={twilio:buildTwilioHandle({callSid:t.callSid,config:e.config,from:t.from,to:t.to})};try{return await e.onVoice(n,t)}catch(e){return log.error(`voice handler failed`,{error:e}),null}}async function dispatchVoiceTranscription(e){let{transcription:t}=e,n={twilio:buildTwilioHandle({callSid:t.callSid,config:e.config,from:t.from,to:t.to})},r;try{r=await e.onVoiceTranscription(n,t)}catch(e){log.error(`voice transcription handler failed`,{error:e});return}if(r==null)return;let i=prependTwilioContext(t.text,{callSid:t.callSid,channel:`voice`,from:t.from,to:t.to});try{await e.send(i,{auth:r.auth,continuationToken:twilioContinuationToken(t.from,t.to),state:{from:t.from,lastCallSid:t.callSid??null,lastMessageSid:null,to:t.to??null}})}catch(e){log.error(`voice transcription delivery failed`,{error:e})}}async function isAllowed(e,t){let n=typeof t==`function`?await t():t;return n===`*`?!0:typeof n==`string`?n===e:n.includes(e)}async function buildActionUrl(e,t,n){let r=typeof t.publicBaseUrl==`function`?await t.publicBaseUrl(e):t.publicBaseUrl;if(r)return new URL(n,ensureTrailingSlash(r)).toString();let i=new URL(e.url);return i.pathname=n,i.search=``,i.toString()}function ensureTrailingSlash(e){return e.endsWith(`/`)?e:`${e}/`}function readString(e){return typeof e==`string`&&e.length>0?e:void 0}export{twilioChannel};

package/dist/src/public/channels/twilio/twiml.js

@@ -1,58 +1 @@
-/**
- * Tiny TwiML builders for Twilio webhook responses.
- *
- * The channel keeps TwiML generation local so callers do not need the
- * Twilio SDK just to acknowledge a webhook or gather speech.
- */
-/** Returns an empty TwiML response, useful for acknowledging inbound SMS without replying. */
-export function emptyTwilioResponse() {
-    return twimlResponse("<Response></Response>");
-}
-/** Returns a TwiML response that speaks `message` and then ends the call. */
-export function sayTwilioResponse(message) {
-    return twimlResponse(`<Response><Say>${escapeXml(message)}</Say></Response>`);
-}
-/** Returns a TwiML response that asks the caller to speak and posts the transcript to `actionUrl`. */
-export function gatherSpeechTwilioResponse(options) {
-    const hints = typeof options.hints === "string" ? options.hints : options.hints?.join(",");
-    const attributes = [
-        `input="speech"`,
-        `action="${escapeXml(options.actionUrl)}"`,
-        `method="POST"`,
-        `actionOnEmptyResult="true"`,
-        options.language ? `language="${escapeXml(options.language)}"` : undefined,
-        options.speechModel ? `speechModel="${escapeXml(options.speechModel)}"` : undefined,
-        options.timeoutSeconds !== undefined ? `timeout="${options.timeoutSeconds}"` : undefined,
-        options.speechTimeout ? `speechTimeout="${escapeXml(options.speechTimeout)}"` : undefined,
-        hints ? `hints="${escapeXml(hints)}"` : undefined,
-        options.profanityFilter !== undefined
-            ? `profanityFilter="${options.profanityFilter ? "true" : "false"}"`
-            : undefined,
-    ]
-        .filter((value) => value !== undefined)
-        .join(" ");
-    const sayAttributes = [
-        options.voice ? `voice="${escapeXml(options.voice)}"` : undefined,
-        options.language ? `language="${escapeXml(options.language)}"` : undefined,
-    ]
-        .filter((value) => value !== undefined)
-        .join(" ");
-    const sayOpen = sayAttributes ? `<Say ${sayAttributes}>` : "<Say>";
-    return twimlResponse(`<Response><Gather ${attributes}>${sayOpen}${escapeXml(options.prompt)}</Say></Gather></Response>`);
-}
-/** Wraps a TwiML string in a Twilio-compatible XML response. */
-export function twimlResponse(twiml) {
-    return new Response(twiml, {
-        status: 200,
-        headers: { "content-type": "text/xml;charset=UTF-8" },
-    });
-}
-/** Escapes text for XML element content or attribute values. */
-export function escapeXml(value) {
-    return value
-        .replaceAll("&", "&amp;")
-        .replaceAll("<", "&lt;")
-        .replaceAll(">", "&gt;")
-        .replaceAll('"', "&quot;")
-        .replaceAll("'", "&apos;");
-}
+function emptyTwilioResponse(){return twimlResponse(`<Response></Response>`)}function sayTwilioResponse(e){return twimlResponse(`<Response><Say>${escapeXml(e)}</Say></Response>`)}function gatherSpeechTwilioResponse(e){let t=typeof e.hints==`string`?e.hints:e.hints?.join(`,`),n=[`input="speech"`,`action="${escapeXml(e.actionUrl)}"`,`method="POST"`,`actionOnEmptyResult="true"`,e.language?`language="${escapeXml(e.language)}"`:void 0,e.speechModel?`speechModel="${escapeXml(e.speechModel)}"`:void 0,e.timeoutSeconds===void 0?void 0:`timeout="${e.timeoutSeconds}"`,e.speechTimeout?`speechTimeout="${escapeXml(e.speechTimeout)}"`:void 0,t?`hints="${escapeXml(t)}"`:void 0,e.profanityFilter===void 0?void 0:`profanityFilter="${e.profanityFilter?`true`:`false`}"`].filter(e=>e!==void 0).join(` `),r=[e.voice?`voice="${escapeXml(e.voice)}"`:void 0,e.language?`language="${escapeXml(e.language)}"`:void 0].filter(e=>e!==void 0).join(` `);return twimlResponse(`<Response><Gather ${n}>${r?`<Say ${r}>`:`<Say>`}${escapeXml(e.prompt)}</Say></Gather></Response>`)}function twimlResponse(e){return new Response(e,{status:200,headers:{"content-type":`text/xml;charset=UTF-8`}})}function escapeXml(e){return e.replaceAll(`&`,`&amp;`).replaceAll(`<`,`&lt;`).replaceAll(`>`,`&gt;`).replaceAll(`"`,`&quot;`).replaceAll(`'`,`&apos;`)}export{emptyTwilioResponse,escapeXml,gatherSpeechTwilioResponse,sayTwilioResponse,twimlResponse};

package/dist/src/public/channels/twilio/verify.js

@@ -1,73 +1 @@
-/**
- * Twilio inbound-webhook verification.
- *
- * Twilio signs webhook requests with `X-Twilio-Signature`. For form
- * posts, the signed payload is the exact public URL Twilio called plus
- * every POST parameter sorted by name and appended as `name + value`.
- */
-import { createHmac, timingSafeEqual } from "node:crypto";
-import { createLogger } from "#internal/logging.js";
-const log = createLogger("twilio.verify");
-/** Resolves a Twilio auth token, falling back to `TWILIO_AUTH_TOKEN`. */
-export async function resolveTwilioAuthToken(authToken) {
-    const source = authToken ?? process.env.TWILIO_AUTH_TOKEN;
-    if (!source)
-        throw new Error("TWILIO_AUTH_TOKEN is required.");
-    return typeof source === "function" ? await source() : source;
-}
-/**
- * Verifies an inbound Twilio webhook and returns the raw body plus form params.
- *
- * Throws when the auth token is missing, the signature header is missing,
- * or the computed signature does not match `X-Twilio-Signature`.
- */
-export async function verifyTwilioRequest(request, options) {
-    const body = await request.text();
-    const params = new URLSearchParams(body);
-    const authToken = await resolveTwilioAuthToken(options.authToken);
-    const signature = request.headers.get("x-twilio-signature") ?? "";
-    if (!signature) {
-        throw new Error("twilioChannel: inbound request missing X-Twilio-Signature.");
-    }
-    const url = await resolveWebhookUrl(request, options.webhookUrl);
-    const expected = signTwilioRequest({ authToken, params, url });
-    if (!constantTimeCompare(expected, signature)) {
-        throw new Error("twilioChannel: inbound request signature mismatch.");
-    }
-    return { body, params };
-}
-/** Computes Twilio's HMAC-SHA1 request signature. */
-export function signTwilioRequest(input) {
-    const base = buildTwilioSignatureBase(input.url, input.params);
-    return createHmac("sha1", input.authToken).update(base).digest("base64");
-}
-/** Builds the string Twilio signs for a form POST webhook. */
-export function buildTwilioSignatureBase(url, params) {
-    const entries = Array.from(params.entries()).sort(([aName, aValue], [bName, bValue]) => {
-        const nameOrder = aName < bName ? -1 : aName > bName ? 1 : 0;
-        if (nameOrder !== 0)
-            return nameOrder;
-        return aValue < bValue ? -1 : aValue > bValue ? 1 : 0;
-    });
-    let base = url;
-    for (const [name, value] of entries) {
-        base += `${name}${value}`;
-    }
-    return base;
-}
-async function resolveWebhookUrl(request, webhookUrl) {
-    if (typeof webhookUrl === "function")
-        return webhookUrl(request);
-    return webhookUrl ?? request.url;
-}
-function constantTimeCompare(a, b) {
-    if (a.length !== b.length)
-        return false;
-    try {
-        return timingSafeEqual(Buffer.from(a), Buffer.from(b));
-    }
-    catch (error) {
-        log.debug("timingSafeEqual threw", { error });
-        return false;
-    }
-}
+import{createLogger}from"#internal/logging.js";import{createHmac,timingSafeEqual}from"node:crypto";var log=createLogger(`twilio.verify`);async function resolveTwilioAuthToken(e){let t=e??process.env.TWILIO_AUTH_TOKEN;if(!t)throw Error(`TWILIO_AUTH_TOKEN is required.`);return typeof t==`function`?await t():t}async function verifyTwilioRequest(e,t){let n=await e.text(),r=new URLSearchParams(n),i=await resolveTwilioAuthToken(t.authToken),a=e.headers.get(`x-twilio-signature`)??``;if(!a)throw Error(`twilioChannel: inbound request missing X-Twilio-Signature.`);if(!constantTimeCompare(signTwilioRequest({authToken:i,params:r,url:await resolveWebhookUrl(e,t.webhookUrl)}),a))throw Error(`twilioChannel: inbound request signature mismatch.`);return{body:n,params:r}}function signTwilioRequest(e){let n=buildTwilioSignatureBase(e.url,e.params);return createHmac(`sha1`,e.authToken).update(n).digest(`base64`)}function buildTwilioSignatureBase(e,t){let n=Array.from(t.entries()).sort(([e,t],[n,r])=>{let i=e<n?-1:+(e>n);return i===0?t<r?-1:+(t>r):i}),r=e;for(let[e,t]of n)r+=`${e}${t}`;return r}async function resolveWebhookUrl(e,t){return typeof t==`function`?t(e):t??e.url}function constantTimeCompare(e,t){if(e.length!==t.length)return!1;try{return timingSafeEqual(Buffer.from(e),Buffer.from(t))}catch(e){return log.debug(`timingSafeEqual threw`,{error:e}),!1}}export{buildTwilioSignatureBase,resolveTwilioAuthToken,signTwilioRequest,verifyTwilioRequest};