experimental-ash 0.25.2 → 0.27.0

package/dist/src/public/channels/slack/slackChannel.js

@@ -1,250 +1 @@
-import { createLogger } from "#internal/logging.js";
-import { buildSlackBinding, slackContinuationToken, } from "#public/channels/slack/api.js";
-import { buildSlackTurnMessage, collectInboundFileParts, createSlackFetchFile, } from "#public/channels/slack/attachments.js";
-import { defaultEvents, defaultInputRequestedHandler, defaultOnAppMention, defaultOnDirectMessage, } from "#public/channels/slack/defaults.js";
-import { parseAppMentionEvent, parseDirectMessageEvent, prependSlackContext, } from "#public/channels/slack/inbound.js";
-import { handleInteractionPost } from "#public/channels/slack/interactions.js";
-import { mergeUploadPolicy, } from "#public/channels/upload-policy.js";
-import { verifySlackRequest } from "#public/channels/slack/verify.js";
-import { defineChannel, POST, } from "#public/definitions/defineChannel.js";
-const log = createLogger("slack.channel");
-function rebuildSlackContext(state, session, credentials) {
-    const { thread, slack } = buildSlackBinding({
-        botToken: credentials?.botToken,
-        channelId: state.channelId ?? "",
-        threadTs: state.threadTs ?? "",
-        teamId: state.teamId ?? undefined,
-        onThreadTsChanged(ts) {
-            state.threadTs = ts;
-            if (state.channelId) {
-                session.setContinuationToken(slackContinuationToken(state.channelId, ts));
-            }
-        },
-    });
-    return { thread, slack, session, state };
-}
-/**
- * Slack channel factory. Wires up the Slack webhook route, mention
- * dispatch, interaction handling, and a baseline set of typing /
- * error / connection-auth event handlers.
- *
- * Defaults apply per field — pass `onAppMention` to fully replace the
- * default mention pipeline (auth derivation + `"Thinking…"` typing),
- * or pass an `events[type]` handler to replace only that one event.
- * Fields you don't supply keep their defaults.
- */
-export function slackChannel(config = {}) {
-    const uploadPolicy = mergeUploadPolicy(config.uploadPolicy);
-    const slackFetchFile = createSlackFetchFile({ botToken: config.credentials?.botToken });
-    const onAppMention = config.onAppMention ?? defaultOnAppMention;
-    const onDirectMessage = config.onDirectMessage ?? defaultOnDirectMessage;
-    const mergedEvents = {
-        ...defaultEvents,
-        ...config.events,
-        "input.requested": config.events?.["input.requested"] ?? defaultInputRequestedHandler(),
-    };
-    return defineChannel({
-        kindHint: "slack",
-        state: {
-            channelId: null,
-            threadTs: null,
-            teamId: null,
-            triggeringUserId: null,
-            pendingToolCallMessage: null,
-            pendingAuthMessageTs: {},
-        },
-        fetchFile: slackFetchFile,
-        context(state, session) {
-            return rebuildSlackContext(state, session, config.credentials);
-        },
-        routes: [
-            POST(config.route ?? "/ash/v1/slack", async (req, { send, waitUntil }) => {
-                const body = await verifyInbound(req, config.credentials);
-                if (body === null)
-                    return new Response("unauthorized", { status: 401 });
-                const contentType = req.headers.get("content-type") ?? "";
-                if (contentType.includes("application/x-www-form-urlencoded")) {
-                    return handleInteractionPost(body, { send, waitUntil }, { config });
-                }
-                return handleEventPost({
-                    body,
-                    send,
-                    waitUntil,
-                    onAppMention,
-                    onDirectMessage,
-                    uploadPolicy,
-                    credentials: config.credentials,
-                });
-            }),
-        ],
-        async receive(input, { send }) {
-            const receiveArgs = input.args;
-            const channelId = receiveArgs.channelId;
-            if (!channelId || typeof channelId !== "string") {
-                throw new Error("slackChannel().receive requires args.channelId.");
-            }
-            const requestedThreadTs = typeof receiveArgs.threadTs === "string" ? receiveArgs.threadTs : "";
-            const initialMessage = receiveArgs.initialMessage;
-            if (initialMessage && requestedThreadTs.length > 0) {
-                throw new Error("slackChannel().receive: `threadTs` and `initialMessage` are mutually exclusive.");
-            }
-            let threadTs = requestedThreadTs;
-            if (initialMessage) {
-                const { thread } = buildSlackBinding({
-                    botToken: config.credentials?.botToken,
-                    channelId,
-                    threadTs: "",
-                    teamId: undefined,
-                });
-                const postInput = {
-                    card: initialMessage.card,
-                };
-                if (initialMessage.fallbackText !== undefined) {
-                    postInput.fallbackText = initialMessage.fallbackText;
-                }
-                const posted = await thread.post(postInput);
-                threadTs = posted.id;
-            }
-            return send(input.message, {
-                auth: input.auth,
-                continuationToken: slackContinuationToken(channelId, threadTs),
-                state: {
-                    channelId,
-                    threadTs: threadTs || null,
-                    teamId: null,
-                    triggeringUserId: null,
-                },
-            });
-        },
-        events: mergedEvents,
-    });
-}
-/**
- * Handles an inbound non-interactivity Slack POST: parses the JSON
- * envelope, answers the URL-verification challenge, routes
- * `app_mention` events through `onAppMention` and `message`
- * events with `channel_type: "im"` through `onDirectMessage`, and
- * dispatches matching events via {@link dispatchInboundMessage} under
- * `waitUntil`. Returns the route's `200 OK` Response in every case
- * (Slack only cares that the webhook ACKs immediately).
- */
-async function handleEventPost(input) {
-    let envelope;
-    try {
-        envelope = JSON.parse(input.body);
-    }
-    catch (error) {
-        log.warn("inbound webhook body is not valid JSON", { error });
-        return new Response("ok");
-    }
-    if (typeof envelope.challenge === "string") {
-        return new Response(envelope.challenge, {
-            status: 200,
-            headers: { "content-type": "text/plain" },
-        });
-    }
-    const mention = parseAppMentionEvent(envelope);
-    if (mention) {
-        input.waitUntil(dispatchInboundMessage({
-            kind: "app_mention",
-            message: mention,
-            handler: input.onAppMention,
-            send: input.send,
-            uploadPolicy: input.uploadPolicy,
-            credentials: input.credentials,
-        }));
-        return new Response("ok");
-    }
-    const dm = parseDirectMessageEvent(envelope);
-    if (dm) {
-        input.waitUntil(dispatchInboundMessage({
-            kind: "direct_message",
-            message: dm,
-            handler: input.onDirectMessage,
-            send: input.send,
-            uploadPolicy: input.uploadPolicy,
-            credentials: input.credentials,
-        }));
-        return new Response("ok");
-    }
-    return new Response("ok");
-}
-/**
- * Verifies the inbound Slack request and returns its raw body, or
- * `null` when verification fails. Failures are logged so misconfigured
- * deployments are visible — the route returns 401 to Slack.
- */
-async function verifyInbound(req, credentials) {
-    try {
-        return await verifySlackRequest(req, {
-            signingSecret: credentials?.signingSecret ??
-                (credentials?.webhookVerifier ? undefined : process.env.SLACK_SIGNING_SECRET),
-            webhookVerifier: credentials?.webhookVerifier,
-        });
-    }
-    catch (error) {
-        log.warn("slack inbound verification failed", { error });
-        return null;
-    }
-}
-/**
- * Runs the inbound handler for an `app_mention` or direct message and,
- * when it returns a non-null result, dispatches the message to the
- * runtime via `send`. Errors are caught and logged so a misbehaving
- * handler never crashes the webhook ACK.
- */
-async function dispatchInboundMessage(input) {
-    const { message, kind } = input;
-    const { thread, slack } = buildSlackBinding({
-        botToken: input.credentials?.botToken,
-        channelId: message.channelId,
-        threadTs: message.threadTs,
-        teamId: message.teamId,
-    });
-    const slackCtx = { thread, slack };
-    let result;
-    try {
-        result = await input.handler(slackCtx, message);
-    }
-    catch (error) {
-        log.error(`${kind} handler failed`, { error });
-        return;
-    }
-    if (result === null || result === undefined)
-        return;
-    const fileParts = await collectInboundFileParts({
-        mention: message,
-        thread,
-        policy: input.uploadPolicy,
-    });
-    const baseMessage = buildSlackTurnMessage(message.markdown, fileParts);
-    const inboundContext = {
-        channelId: message.channelId,
-        fullName: message.author?.fullName,
-        teamId: message.teamId,
-        threadTs: message.threadTs,
-        userId: message.author?.userId ?? "",
-        userName: message.author?.userName,
-    };
-    const turnMessage = inboundContext.userId
-        ? prependSlackContext(baseMessage, inboundContext)
-        : baseMessage;
-    try {
-        await input.send({
-            message: turnMessage,
-            modelContext: result.modelContext,
-        }, {
-            auth: result.auth,
-            continuationToken: slackContinuationToken(message.channelId, message.threadTs),
-            state: {
-                channelId: message.channelId,
-                threadTs: message.threadTs,
-                teamId: message.teamId ?? null,
-                triggeringUserId: inboundContext.userId || null,
-            },
-        });
-    }
-    catch (error) {
-        log.error(`${kind} delivery failed`, { error });
-    }
-}
+import{createLogger}from"#internal/logging.js";import{mergeUploadPolicy}from"#public/channels/upload-policy.js";import{POST,defineChannel}from"#public/definitions/defineChannel.js";import{buildSlackBinding,slackContinuationToken}from"#public/channels/slack/api.js";import{defaultEvents,defaultInputRequestedHandler,defaultOnAppMention,defaultOnDirectMessage}from"#public/channels/slack/defaults.js";import{buildSlackTurnMessage,collectInboundFileParts,createSlackFetchFile}from"#public/channels/slack/attachments.js";import{parseAppMentionEvent,parseDirectMessageEvent,prependSlackContext}from"#public/channels/slack/inbound.js";import{SLACK_CHANNEL_DEFAULT_ROUTE}from"#public/channels/slack/constants.js";import{handleInteractionPost}from"#public/channels/slack/interactions.js";import{verifySlackRequest}from"#public/channels/slack/verify.js";var log=createLogger(`slack.channel`);function rebuildSlackContext(e,t,n){let{thread:r,slack:a}=buildSlackBinding({botToken:n?.botToken,channelId:e.channelId??``,threadTs:e.threadTs??``,teamId:e.teamId??void 0,onThreadTsChanged(n){e.threadTs=n,e.channelId&&t.setContinuationToken(slackContinuationToken(e.channelId,n))}});return{thread:r,slack:a,session:t,state:e}}function slackChannel(e={}){let l=mergeUploadPolicy(e.uploadPolicy),u=createSlackFetchFile({botToken:e.credentials?.botToken}),f=e.onAppMention??defaultOnAppMention,p=e.onDirectMessage??defaultOnDirectMessage,m={...defaultEvents,...e.events,"input.requested":e.events?.[`input.requested`]??defaultInputRequestedHandler()};return defineChannel({kindHint:`slack`,state:{channelId:null,threadTs:null,teamId:null,triggeringUserId:null,pendingToolCallMessage:null,pendingAuthMessageTs:{}},fetchFile:u,context(t,n){return rebuildSlackContext(t,n,e.credentials)},routes:[POST(e.route??SLACK_CHANNEL_DEFAULT_ROUTE,async(t,{send:n,waitUntil:r})=>{let i=await verifyInbound(t,e.credentials);return i===null?new Response(`unauthorized`,{status:401}):(t.headers.get(`content-type`)??``).includes(`application/x-www-form-urlencoded`)?handleInteractionPost(i,{send:n,waitUntil:r},{config:e}):handleEventPost({body:i,send:n,waitUntil:r,onAppMention:f,onDirectMessage:p,uploadPolicy:l,credentials:e.credentials})})],async receive(t,{send:n}){let r=t.args,a=r.channelId;if(!a||typeof a!=`string`)throw Error(`slackChannel().receive requires args.channelId.`);let o=typeof r.threadTs==`string`?r.threadTs:``,s=r.initialMessage;if(s&&o.length>0)throw Error("slackChannel().receive: `threadTs` and `initialMessage` are mutually exclusive.");let c=o;if(s){let{thread:t}=buildSlackBinding({botToken:e.credentials?.botToken,channelId:a,threadTs:``,teamId:void 0}),n={card:s.card};s.fallbackText!==void 0&&(n.fallbackText=s.fallbackText),c=(await t.post(n)).id}return n(t.message,{auth:t.auth,continuationToken:slackContinuationToken(a,c),state:{channelId:a,threadTs:c||null,teamId:null,triggeringUserId:null}})},events:m})}async function handleEventPost(e){let t;try{t=JSON.parse(e.body)}catch(e){return log.warn(`inbound webhook body is not valid JSON`,{error:e}),new Response(`ok`)}if(typeof t.challenge==`string`)return new Response(t.challenge,{status:200,headers:{"content-type":`text/plain`}});let n=parseAppMentionEvent(t);if(n)return e.waitUntil(dispatchInboundMessage({kind:`app_mention`,message:n,handler:e.onAppMention,send:e.send,uploadPolicy:e.uploadPolicy,credentials:e.credentials})),new Response(`ok`);let r=parseDirectMessageEvent(t);return r&&e.waitUntil(dispatchInboundMessage({kind:`direct_message`,message:r,handler:e.onDirectMessage,send:e.send,uploadPolicy:e.uploadPolicy,credentials:e.credentials})),new Response(`ok`)}async function verifyInbound(e,t){try{return await verifySlackRequest(e,{signingSecret:t?.signingSecret??(t?.webhookVerifier?void 0:process.env.SLACK_SIGNING_SECRET),webhookVerifier:t?.webhookVerifier})}catch(e){return log.warn(`slack inbound verification failed`,{error:e}),null}}async function dispatchInboundMessage(e){let{message:t,kind:n}=e,{thread:r,slack:a}=buildSlackBinding({botToken:e.credentials?.botToken,channelId:t.channelId,threadTs:t.threadTs,teamId:t.teamId}),o={thread:r,slack:a},s;try{s=await e.handler(o,t)}catch(e){log.error(`${n} handler failed`,{error:e});return}if(s==null)return;let c=await collectInboundFileParts({mention:t,thread:r,policy:e.uploadPolicy}),d=buildSlackTurnMessage(t.markdown,c),f={channelId:t.channelId,fullName:t.author?.fullName,teamId:t.teamId,threadTs:t.threadTs,userId:t.author?.userId??``,userName:t.author?.userName},p=f.userId?prependSlackContext(d,f):d;try{await e.send({message:p,modelContext:s.modelContext},{auth:s.auth,continuationToken:slackContinuationToken(t.channelId,t.threadTs),state:{channelId:t.channelId,threadTs:t.threadTs,teamId:t.teamId??null,triggeringUserId:f.userId||null}})}catch(e){log.error(`${n} delivery failed`,{error:e})}}export{slackChannel};

package/dist/src/public/channels/slack/thread.js

@@ -1,45 +1 @@
-/**
- * Loads messages that are useful as background context for the current
- * Slack thread turn.
- *
- * Returns an empty array when `message` is the thread root. For thread
- * replies, refreshes the bound Slack thread and returns its recent
- * messages before the triggering message, filtered by {@link options}.
- * Formatting and model-message role choice stay with the caller.
- */
-export async function loadThreadContextMessages(thread, message, options = {}) {
-    if (isThreadRootMessage(message)) {
-        return [];
-    }
-    await thread.refresh();
-    const currentIndex = thread.recentMessages.findIndex((entry) => entry.ts === message.ts);
-    const candidateMessages = currentIndex === -1 ? thread.recentMessages : thread.recentMessages.slice(0, currentIndex);
-    const priorMessages = candidateMessages.filter((entry) => entry.threadTs === message.threadTs && entry.ts !== message.ts);
-    return applySinceBoundary(priorMessages, options.since);
-}
-function isThreadRootMessage(message) {
-    return message.threadTs === message.ts;
-}
-function findLastIndex(items, predicate) {
-    for (let index = items.length - 1; index >= 0; index -= 1) {
-        if (predicate(items[index])) {
-            return index;
-        }
-    }
-    return -1;
-}
-function applySinceBoundary(messages, since) {
-    const boundary = since ?? "thread-root";
-    if (typeof boundary === "function") {
-        const lastMatchingIndex = findLastIndex(messages, boundary);
-        return messages.slice(lastMatchingIndex + 1);
-    }
-    switch (boundary) {
-        case "thread-root":
-            return [...messages];
-        case "last-agent-reply": {
-            const lastAgentReplyIndex = findLastIndex(messages, (entry) => entry.isMe);
-            return messages.slice(lastAgentReplyIndex + 1);
-        }
-    }
-}
+async function loadThreadContextMessages(e,t,n={}){if(isThreadRootMessage(t))return[];await e.refresh();let r=e.recentMessages.findIndex(e=>e.ts===t.ts);return applySinceBoundary((r===-1?e.recentMessages:e.recentMessages.slice(0,r)).filter(e=>e.threadTs===t.threadTs&&e.ts!==t.ts),n.since)}function isThreadRootMessage(e){return e.threadTs===e.ts}function findLastIndex(e,t){for(let n=e.length-1;n>=0;--n)if(t(e[n]))return n;return-1}function applySinceBoundary(e,t){let n=t??`thread-root`;if(typeof n==`function`){let t=findLastIndex(e,n);return e.slice(t+1)}switch(n){case`thread-root`:return[...e];case`last-agent-reply`:{let t=findLastIndex(e,e=>e.isMe);return e.slice(t+1)}}}export{loadThreadContextMessages};

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

@@ -1,70 +1 @@
-/**
- * Slack inbound-webhook verification.
- *
- * The native channel replaces `createSlackAdapter`'s built-in HMAC
- * check with a self-contained verifier:
- *
- * 1. If the caller supplied a {@link SlackWebhookVerifier} (e.g.
- *    Connect's OIDC-based forwarder), delegate to it.
- * 2. Otherwise, recompute the Slack v0 HMAC and compare with
- *    `X-Slack-Signature`. Rejects requests older than five minutes to
- *    foil replay attacks.
- *
- * Returns the verified raw body string on success so the caller can
- * parse it without re-reading the request stream.
- */
-import { createHmac, timingSafeEqual } from "node:crypto";
-import { createLogger } from "#internal/logging.js";
-const log = createLogger("slack.verify");
-/**
- * Verifies an inbound Slack webhook and returns its raw body.
- *
- * Throws when neither a signing secret nor a custom verifier is
- * available, when signature/timestamp checks fail, or when the
- * caller-supplied verifier rejects.
- */
-export async function verifySlackRequest(request, options) {
-    const body = await request.text();
-    if (options.webhookVerifier !== undefined) {
-        const result = await options.webhookVerifier(request, body);
-        if (!result) {
-            throw new Error("slackChannel: inbound webhook verifier rejected the request.");
-        }
-        return typeof result === "string" ? result : body;
-    }
-    if (!options.signingSecret) {
-        throw new Error("slackChannel: missing signing secret. Pass credentials.signingSecret, " +
-            "set SLACK_SIGNING_SECRET, or supply credentials.webhookVerifier.");
-    }
-    const timestampHeader = request.headers.get("x-slack-request-timestamp") ?? "";
-    const signatureHeader = request.headers.get("x-slack-signature") ?? "";
-    if (!timestampHeader || !signatureHeader) {
-        throw new Error("slackChannel: inbound request missing Slack signature headers.");
-    }
-    const timestamp = Number(timestampHeader);
-    if (!Number.isFinite(timestamp)) {
-        throw new Error("slackChannel: inbound request has malformed timestamp.");
-    }
-    const maxSkew = options.maxSkewSeconds ?? 60 * 5;
-    const now = Math.floor(Date.now() / 1000);
-    if (Math.abs(now - timestamp) > maxSkew) {
-        throw new Error("slackChannel: inbound request timestamp outside allowed skew.");
-    }
-    const base = `v0:${timestampHeader}:${body}`;
-    const expected = `v0=${createHmac("sha256", options.signingSecret).update(base).digest("hex")}`;
-    if (!constantTimeCompare(expected, signatureHeader)) {
-        throw new Error("slackChannel: inbound request signature mismatch.");
-    }
-    return body;
-}
-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(`slack.verify`);async function verifySlackRequest(e,n){let r=await e.text();if(n.webhookVerifier!==void 0){let t=await n.webhookVerifier(e,r);if(!t)throw Error(`slackChannel: inbound webhook verifier rejected the request.`);return typeof t==`string`?t:r}if(!n.signingSecret)throw Error(`slackChannel: missing signing secret. Pass credentials.signingSecret, set SLACK_SIGNING_SECRET, or supply credentials.webhookVerifier.`);let i=e.headers.get(`x-slack-request-timestamp`)??``,a=e.headers.get(`x-slack-signature`)??``;if(!i||!a)throw Error(`slackChannel: inbound request missing Slack signature headers.`);let o=Number(i);if(!Number.isFinite(o))throw Error(`slackChannel: inbound request has malformed timestamp.`);let s=n.maxSkewSeconds??300,c=Math.floor(Date.now()/1e3);if(Math.abs(c-o)>s)throw Error(`slackChannel: inbound request timestamp outside allowed skew.`);let l=`v0:${i}:${r}`;if(!constantTimeCompare(`v0=${createHmac(`sha256`,n.signingSecret).update(l).digest(`hex`)}`,a))throw Error(`slackChannel: inbound request signature mismatch.`);return r}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{verifySlackRequest};

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

@@ -1,103 +1 @@
-/**
- * Minimal Twilio REST API wrapper used by the Twilio channel.
- *
- * Requests use Twilio's normal `application/x-www-form-urlencoded`
- * body encoding and HTTP Basic auth. No Twilio SDK dependency is
- * required or exposed through Ash public APIs.
- */
-import { resolveTwilioAuthToken } from "#public/channels/twilio/verify.js";
-/**
- * Builds the Twilio channel-local continuation token
- * (`<from>:<to>`). Route `send()` namespaces this with the channel
- * name before handing it to the runtime (`twilio:<from>:<to>`), so
- * Twilio routes should pass the raw channel-local form returned
- * here. `to` may be empty for proactive sessions that don't yet know
- * the Twilio sender number.
- */
-export function twilioContinuationToken(from, to) {
-    return `${from}:${to ?? ""}`;
-}
-/** Resolves a Twilio Account SID, falling back to `TWILIO_ACCOUNT_SID`. */
-export async function resolveTwilioAccountSid(accountSid) {
-    const source = accountSid ?? process.env.TWILIO_ACCOUNT_SID;
-    if (!source)
-        throw new Error("TWILIO_ACCOUNT_SID is required.");
-    return typeof source === "function" ? await source() : source;
-}
-/**
- * Calls Twilio's REST API with Basic auth and form-encoded body fields.
- *
- * `path` is relative to `https://api.twilio.com` by default and may be
- * pointed elsewhere through `apiBaseUrl` for tests or proxies.
- */
-export async function callTwilioApi(input) {
-    const accountSid = await resolveTwilioAccountSid(input.credentials?.accountSid);
-    const authToken = await resolveTwilioAuthToken(input.credentials?.authToken);
-    const apiFetch = input.fetch ?? fetch;
-    const url = `${input.apiBaseUrl ?? "https://api.twilio.com"}${input.path}`;
-    const body = encodeForm(input.body);
-    const response = await apiFetch(url, {
-        method: "POST",
-        headers: {
-            authorization: `Basic ${Buffer.from(`${accountSid}:${authToken}`).toString("base64")}`,
-            "content-type": "application/x-www-form-urlencoded;charset=UTF-8",
-        },
-        body,
-    });
-    return {
-        status: response.status,
-        ok: response.ok,
-        body: await parseResponseBody(response),
-    };
-}
-/** Sends an outbound SMS/MMS-style message via Twilio's Messages resource. */
-export async function sendTwilioMessage(input) {
-    if (!input.from && !input.messagingServiceSid) {
-        throw new Error("twilioChannel: sending a message requires from or messagingServiceSid.");
-    }
-    const accountSid = await resolveTwilioAccountSid(input.credentials?.accountSid);
-    return callTwilioApi({
-        apiBaseUrl: input.apiBaseUrl,
-        credentials: input.credentials,
-        fetch: input.fetch,
-        path: `/2010-04-01/Accounts/${encodeURIComponent(accountSid)}/Messages.json`,
-        body: {
-            Body: input.body,
-            From: input.from,
-            MessagingServiceSid: input.messagingServiceSid,
-            StatusCallback: input.statusCallbackUrl,
-            To: input.to,
-        },
-    });
-}
-/** Updates a live Twilio call by posting replacement TwiML to the Calls resource. */
-export async function updateTwilioCall(input) {
-    const accountSid = await resolveTwilioAccountSid(input.credentials?.accountSid);
-    return callTwilioApi({
-        apiBaseUrl: input.apiBaseUrl,
-        credentials: input.credentials,
-        fetch: input.fetch,
-        path: `/2010-04-01/Accounts/${encodeURIComponent(accountSid)}/Calls/${encodeURIComponent(input.callSid)}.json`,
-        body: { Twiml: input.twiml },
-    });
-}
-function encodeForm(body) {
-    const params = new URLSearchParams();
-    for (const [key, value] of Object.entries(body)) {
-        if (value === undefined || value === null)
-            continue;
-        params.set(key, String(value));
-    }
-    return params;
-}
-async function parseResponseBody(response) {
-    const text = await response.text();
-    if (!text)
-        return null;
-    try {
-        return JSON.parse(text);
-    }
-    catch {
-        return text;
-    }
-}
+import{resolveTwilioAuthToken}from"#public/channels/twilio/verify.js";function twilioContinuationToken(e,t){return`${e}:${t??``}`}async function resolveTwilioAccountSid(e){let t=e??process.env.TWILIO_ACCOUNT_SID;if(!t)throw Error(`TWILIO_ACCOUNT_SID is required.`);return typeof t==`function`?await t():t}async function callTwilioApi(t){let n=await resolveTwilioAccountSid(t.credentials?.accountSid),r=await resolveTwilioAuthToken(t.credentials?.authToken),i=t.fetch??fetch,a=`${t.apiBaseUrl??`https://api.twilio.com`}${t.path}`,o=encodeForm(t.body),s=await i(a,{method:`POST`,headers:{authorization:`Basic ${Buffer.from(`${n}:${r}`).toString(`base64`)}`,"content-type":`application/x-www-form-urlencoded;charset=UTF-8`},body:o});return{status:s.status,ok:s.ok,body:await parseResponseBody(s)}}async function sendTwilioMessage(e){if(!e.from&&!e.messagingServiceSid)throw Error(`twilioChannel: sending a message requires from or messagingServiceSid.`);let t=await resolveTwilioAccountSid(e.credentials?.accountSid);return callTwilioApi({apiBaseUrl:e.apiBaseUrl,credentials:e.credentials,fetch:e.fetch,path:`/2010-04-01/Accounts/${encodeURIComponent(t)}/Messages.json`,body:{Body:e.body,From:e.from,MessagingServiceSid:e.messagingServiceSid,StatusCallback:e.statusCallbackUrl,To:e.to}})}async function updateTwilioCall(e){let t=await resolveTwilioAccountSid(e.credentials?.accountSid);return callTwilioApi({apiBaseUrl:e.apiBaseUrl,credentials:e.credentials,fetch:e.fetch,path:`/2010-04-01/Accounts/${encodeURIComponent(t)}/Calls/${encodeURIComponent(e.callSid)}.json`,body:{Twiml:e.twiml}})}function encodeForm(e){let t=new URLSearchParams;for(let[n,r]of Object.entries(e))r!=null&&t.set(n,String(r));return t}async function parseResponseBody(e){let t=await e.text();if(!t)return null;try{return JSON.parse(t)}catch{return t}}export{callTwilioApi,resolveTwilioAccountSid,sendTwilioMessage,twilioContinuationToken,updateTwilioCall};

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

@@ -1,69 +1,3 @@
-import { extractErrorId, formatErrorHint } from "#internal/logging.js";
-/** Default phone-number auth projection for Twilio webhook actors. */
-export function defaultTwilioAuth(input) {
-    const attributes = {
-        channel: input.channel,
-        from: input.from,
-    };
-    if (input.to !== undefined)
-        attributes.to = input.to;
-    return {
-        attributes,
-        authenticator: "twilio-webhook",
-        issuer: "twilio",
-        principalId: `twilio:${input.from}`,
-        principalType: "user",
-    };
-}
-/** Default inbound text hook: dispatch with Twilio phone-number auth. */
-export function defaultOnText(_ctx, message) {
-    return {
-        auth: defaultTwilioAuth({
-            channel: "text",
-            from: message.from,
-            to: message.to,
-        }),
-    };
-}
-/** Default inbound voice hook: accept the call with configured voice defaults. */
-export function defaultOnVoice(_ctx, _call) {
-    return {};
-}
-/** Default inbound voice hook: dispatch with Twilio phone-number auth. */
-export function defaultOnVoiceTranscription(_ctx, transcription) {
-    return {
-        auth: defaultTwilioAuth({
-            channel: "voice",
-            from: transcription.from,
-            to: transcription.to,
-        }),
-    };
-}
-/** Built-in Twilio event handlers for text delivery and terminal errors. */
-export const defaultEvents = {
-    async "message.completed"(event, ctx) {
-        if (event.finishReason === "tool-calls" || !event.message)
-            return;
-        await ctx.twilio.sendMessage(event.message);
-    },
-    async "turn.failed"(event, ctx) {
-        const hint = formatErrorHint(event);
-        const errorId = extractErrorId(event.details);
-        await ctx.twilio.sendMessage([
-            `I hit an error while handling your request${hint}.`,
-            "",
-            "Please try again, rephrase, or reach out if it keeps failing.",
-            ...(errorId ? ["", `Error id: ${errorId}`] : []),
-        ].join("\n"));
-    },
-    async "session.failed"(event, ctx) {
-        const hint = formatErrorHint(event);
-        const errorId = extractErrorId(event.details);
-        await ctx.twilio.sendMessage([
-            `This session could not recover from an error${hint}.`,
-            "",
-            "Start a new message to continue.",
-            ...(errorId ? ["", `Error id: ${errorId}`] : []),
-        ].join("\n"));
-    },
-};
+import{extractErrorId,formatErrorHint}from"#internal/logging.js";function defaultTwilioAuth(e){let t={channel:e.channel,from:e.from};return e.to!==void 0&&(t.to=e.to),{attributes:t,authenticator:`twilio-webhook`,issuer:`twilio`,principalId:`twilio:${e.from}`,principalType:`user`}}function defaultOnText(e,t){return{auth:defaultTwilioAuth({channel:`text`,from:t.from,to:t.to})}}function defaultOnVoice(e,t){return{}}function defaultOnVoiceTranscription(e,t){return{auth:defaultTwilioAuth({channel:`voice`,from:t.from,to:t.to})}}var defaultEvents={async"message.completed"(e,t){e.finishReason===`tool-calls`||!e.message||await t.twilio.sendMessage(e.message)},async"turn.failed"(n,r){let i=formatErrorHint(n),a=extractErrorId(n.details);await r.twilio.sendMessage([`I hit an error while handling your request${i}.`,``,`Please try again, rephrase, or reach out if it keeps failing.`,...a?[``,`Error id: ${a}`]:[]].join(`
+`))},async"session.failed"(n,r){let i=formatErrorHint(n),a=extractErrorId(n.details);await r.twilio.sendMessage([`This session could not recover from an error${i}.`,``,`Start a new message to continue.`,...a?[``,`Error id: ${a}`]:[]].join(`
+`))}};export{defaultEvents,defaultOnText,defaultOnVoice,defaultOnVoiceTranscription,defaultTwilioAuth};