experimental-ash 0.26.0 → 0.28.0

package/dist/src/public/channels/telegram/inbound.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Inbound Telegram update parsing and prompt shaping.
+ *
+ * The channel owns small, documented data shapes instead of exposing
+ * Telegram's raw webhook payloads as the primary public API.
+ */
+import type { UserContent } from "ai";
+/** Telegram chat types handled by the native channel. */
+export type TelegramChatType = "channel" | "group" | "private" | "supergroup";
+/** Telegram user metadata surfaced by inbound messages and callbacks. */
+export interface TelegramUser {
+    readonly firstName?: string;
+    readonly id: string;
+    readonly isBot: boolean;
+    readonly languageCode?: string;
+    readonly lastName?: string;
+    readonly username?: string;
+}
+/** Telegram chat metadata surfaced by inbound messages. */
+export interface TelegramChat {
+    readonly id: string;
+    readonly title?: string;
+    readonly type: TelegramChatType;
+    readonly username?: string;
+}
+/** Inbound Telegram file attachment. */
+export interface TelegramAttachment {
+    readonly fileId: string;
+    readonly fileName?: string;
+    readonly fileUniqueId?: string;
+    readonly height?: number;
+    readonly kind: "document" | "photo";
+    readonly mediaType?: string;
+    readonly size?: number;
+    readonly width?: number;
+}
+/** Minimal Telegram message representation nested on replies/callbacks. */
+export interface TelegramMessageReference {
+    readonly chat: TelegramChat;
+    readonly from?: TelegramUser;
+    readonly messageId: string;
+    readonly messageThreadId?: number;
+}
+/** Channel-owned representation of one inbound Telegram message. */
+export interface TelegramMessage {
+    readonly attachments: readonly TelegramAttachment[];
+    readonly caption: string;
+    readonly chat: TelegramChat;
+    readonly from?: TelegramUser;
+    readonly messageId: string;
+    readonly messageThreadId?: number;
+    readonly raw: Record<string, unknown>;
+    readonly replyToMessage?: TelegramMessageReference;
+    readonly text: string;
+}
+/** Channel-owned representation of one inbound Telegram callback query. */
+export interface TelegramCallbackQuery {
+    readonly data?: string;
+    readonly from: TelegramUser;
+    readonly id: string;
+    readonly message?: TelegramMessageReference;
+    readonly raw: Record<string, unknown>;
+}
+/** Telegram update variants handled by the native channel. */
+export type TelegramUpdate = {
+    readonly kind: "callback_query";
+    readonly callbackQuery: TelegramCallbackQuery;
+} | {
+    readonly kind: "message";
+    readonly message: TelegramMessage;
+};
+/** Inbound identity and response guidance rendered into the model-visible context block. */
+export interface TelegramInboundContext {
+    readonly botUsername?: string;
+    readonly chatId: string;
+    readonly chatTitle?: string;
+    readonly chatType: TelegramChatType;
+    readonly messageId: string;
+    readonly messageThreadId?: number;
+    readonly userId?: string;
+    readonly username?: string;
+}
+/** Parses one JSON-decoded Telegram update payload. */
+export declare function parseTelegramUpdate(value: unknown): TelegramUpdate | null;
+/** Renders one {@link TelegramInboundContext} as a deterministic context block. */
+export declare function formatTelegramContextBlock(context: TelegramInboundContext): string;
+/** Prepends a `<telegram_context>` block to the inbound turn message. */
+export declare function prependTelegramContext(message: string | UserContent, context: TelegramInboundContext): string | UserContent;

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

@@ -0,0 +1,2 @@
+import{isNonEmptyString,isObject}from"#shared/guards.js";var TELEGRAM_RESPONSE_INSTRUCTIONS=`Reply for Telegram in concise plain text. Avoid tables, long code fences, and formatting that depends on Markdown rendering.`;function parseTelegramUpdate(e){if(!isObject(e))return null;let n=parseTelegramMessage(e.message);if(n!==null)return{kind:`message`,message:n};let r=parseTelegramCallbackQuery(e.callback_query);return r===null?null:{callbackQuery:r,kind:`callback_query`}}function formatTelegramContextBlock(e){return[`<telegram_context>`,`response_medium: telegram`,`response_instructions: ${TELEGRAM_RESPONSE_INSTRUCTIONS}`,`chat_id: ${e.chatId}`,`chat_type: ${e.chatType}`,...e.chatTitle?[`chat_title: ${e.chatTitle}`]:[],`message_id: ${e.messageId}`,...e.messageThreadId===void 0?[]:[`message_thread_id: ${e.messageThreadId}`],...e.userId?[`user_id: ${e.userId}`]:[],...e.username?[`username: ${e.username}`]:[],...e.botUsername?[`bot_username: ${e.botUsername}`]:[],`</telegram_context>`].join(`
+`)}function prependTelegramContext(e,t){let n=formatTelegramContextBlock(t);return typeof e==`string`?e.length>0?`${n}\n\n${e}`:n:[{type:`text`,text:n},...e]}function parseTelegramMessage(e){if(!isObject(e))return null;let n=parseTelegramChat(e.chat),r=numberLikeToString(e.message_id);return!n||!r?null:{attachments:parseAttachments(e),caption:typeof e.caption==`string`?e.caption:``,chat:n,from:parseTelegramUser(e.from),messageId:r,messageThreadId:typeof e.message_thread_id==`number`?e.message_thread_id:void 0,raw:e,replyToMessage:parseMessageReference(e.reply_to_message),text:typeof e.text==`string`?e.text:``}}function parseTelegramCallbackQuery(n){if(!isObject(n)||!isNonEmptyString(n.id))return null;let r=parseTelegramUser(n.from);return r?{data:typeof n.data==`string`?n.data:void 0,from:r,id:n.id,message:parseMessageReference(n.message),raw:n}:null}function parseMessageReference(e){if(!isObject(e))return;let n=parseTelegramChat(e.chat),r=numberLikeToString(e.message_id);if(!(!n||!r))return{chat:n,from:parseTelegramUser(e.from),messageId:r,messageThreadId:typeof e.message_thread_id==`number`?e.message_thread_id:void 0}}function parseTelegramChat(e){if(!isObject(e))return null;let n=numberLikeToString(e.id),r=parseChatType(e.type);return!n||!r?null:{id:n,title:typeof e.title==`string`?e.title:void 0,type:r,username:typeof e.username==`string`?e.username:void 0}}function parseTelegramUser(e){if(!isObject(e))return;let n=numberLikeToString(e.id);if(n)return{firstName:typeof e.first_name==`string`?e.first_name:void 0,id:n,isBot:e.is_bot===!0,languageCode:typeof e.language_code==`string`?e.language_code:void 0,lastName:typeof e.last_name==`string`?e.last_name:void 0,username:typeof e.username==`string`?e.username:void 0}}function parseAttachments(e){let t=[],n=parseLargestPhoto(e.photo);n!==null&&t.push(n);let r=parseDocument(e.document);return r!==null&&t.push(r),t}function parseLargestPhoto(e){if(!Array.isArray(e)||e.length===0)return null;let n=e.filter(isObject).map(e=>({fileId:typeof e.file_id==`string`?e.file_id:``,fileUniqueId:typeof e.file_unique_id==`string`?e.file_unique_id:void 0,height:typeof e.height==`number`?e.height:void 0,size:typeof e.file_size==`number`?e.file_size:void 0,width:typeof e.width==`number`?e.width:void 0})).filter(e=>e.fileId.length>0).sort((e,t)=>scorePhoto(t)-scorePhoto(e))[0];return n?{fileId:n.fileId,fileName:`photo.jpg`,fileUniqueId:n.fileUniqueId,height:n.height,kind:`photo`,mediaType:`image/jpeg`,size:n.size,width:n.width}:null}function parseDocument(e){return!isObject(e)||typeof e.file_id!=`string`?null:{fileId:e.file_id,fileName:typeof e.file_name==`string`?e.file_name:void 0,fileUniqueId:typeof e.file_unique_id==`string`?e.file_unique_id:void 0,kind:`document`,mediaType:typeof e.mime_type==`string`?e.mime_type:void 0,size:typeof e.file_size==`number`?e.file_size:void 0}}function scorePhoto(e){return e.size===void 0?(e.width??0)*(e.height??0):e.size}function parseChatType(e){return e===`channel`||e===`group`||e===`private`||e===`supergroup`?e:null}function numberLikeToString(e){if(typeof e==`string`&&e.length>0)return e;if(typeof e==`number`&&Number.isFinite(e))return String(e)}export{formatTelegramContextBlock,parseTelegramUpdate,prependTelegramContext};

package/dist/src/public/channels/telegram/index.d.ts

@@ -0,0 +1,8 @@
+export type { ModelMessage } from "ai";
+export { telegramChannel, type TelegramChannel, type TelegramChannelConfig, type TelegramChannelCredentials, type TelegramChannelEvents, type TelegramChannelState, type TelegramContext, type TelegramEventContext, type TelegramHandle, type TelegramInboundResult, type TelegramInboundResultOrPromise, type TelegramReceiveArgs, } from "#public/channels/telegram/telegramChannel.js";
+export { callTelegramApi, answerTelegramCallbackQuery, downloadTelegramFile, editTelegramMessageReplyMarkup, getTelegramFile, resolveTelegramBotToken, sendTelegramChatAction, sendTelegramMessage, splitTelegramMessageText, telegramContinuationToken, TELEGRAM_MESSAGE_TEXT_MAX_LENGTH, type TelegramApiOptions, type TelegramApiResponse, type TelegramBotToken, type TelegramCredentials, type TelegramFetch, type TelegramMessageBody, type TelegramMessageResult, } from "#public/channels/telegram/api.js";
+export { formatTelegramContextBlock, parseTelegramUpdate, prependTelegramContext, type TelegramAttachment, type TelegramCallbackQuery, type TelegramChat, type TelegramChatType, type TelegramInboundContext, type TelegramMessage, type TelegramMessageReference, type TelegramUpdate, type TelegramUser, } from "#public/channels/telegram/inbound.js";
+export { TELEGRAM_CALLBACK_RESPONSE_PREFIX, TELEGRAM_HITL_CALLBACK_PREFIX, TELEGRAM_REPLY_RESPONSE_PREFIX, isTelegramSyntheticResponse, registerTelegramFreeformPrompt, renderTelegramInputRequest, resolveTelegramInputResponses, telegramCallbackInputResponse, telegramReplyInputResponse, type TelegramHitlState, type TelegramInputRequestMessage, } from "#public/channels/telegram/hitl.js";
+export { TELEGRAM_FILE_URL_PROTOCOL, buildTelegramTurnMessage, collectTelegramFileParts, createTelegramFetchFile, createTelegramFileUrl, } from "#public/channels/telegram/attachments.js";
+export { defaultTelegramAuth } from "#public/channels/telegram/defaults.js";
+export { resolveTelegramWebhookSecretToken, verifyTelegramRequest, type TelegramVerifyOptions, type TelegramWebhookSecretToken, type TelegramWebhookVerifier, } from "#public/channels/telegram/verify.js";

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

@@ -0,0 +1 @@
+import{TELEGRAM_MESSAGE_TEXT_MAX_LENGTH,answerTelegramCallbackQuery,callTelegramApi,downloadTelegramFile,editTelegramMessageReplyMarkup,getTelegramFile,resolveTelegramBotToken,sendTelegramChatAction,sendTelegramMessage,splitTelegramMessageText,telegramContinuationToken}from"#public/channels/telegram/api.js";import{TELEGRAM_CALLBACK_RESPONSE_PREFIX,TELEGRAM_HITL_CALLBACK_PREFIX,TELEGRAM_REPLY_RESPONSE_PREFIX,isTelegramSyntheticResponse,registerTelegramFreeformPrompt,renderTelegramInputRequest,resolveTelegramInputResponses,telegramCallbackInputResponse,telegramReplyInputResponse}from"#public/channels/telegram/hitl.js";import{telegramChannel}from"#public/channels/telegram/telegramChannel.js";import{formatTelegramContextBlock,parseTelegramUpdate,prependTelegramContext}from"#public/channels/telegram/inbound.js";import{TELEGRAM_FILE_URL_PROTOCOL,buildTelegramTurnMessage,collectTelegramFileParts,createTelegramFetchFile,createTelegramFileUrl}from"#public/channels/telegram/attachments.js";import{defaultTelegramAuth}from"#public/channels/telegram/defaults.js";import{resolveTelegramWebhookSecretToken,verifyTelegramRequest}from"#public/channels/telegram/verify.js";export{TELEGRAM_CALLBACK_RESPONSE_PREFIX,TELEGRAM_FILE_URL_PROTOCOL,TELEGRAM_HITL_CALLBACK_PREFIX,TELEGRAM_MESSAGE_TEXT_MAX_LENGTH,TELEGRAM_REPLY_RESPONSE_PREFIX,answerTelegramCallbackQuery,buildTelegramTurnMessage,callTelegramApi,collectTelegramFileParts,createTelegramFetchFile,createTelegramFileUrl,defaultTelegramAuth,downloadTelegramFile,editTelegramMessageReplyMarkup,formatTelegramContextBlock,getTelegramFile,isTelegramSyntheticResponse,parseTelegramUpdate,prependTelegramContext,registerTelegramFreeformPrompt,renderTelegramInputRequest,resolveTelegramBotToken,resolveTelegramInputResponses,resolveTelegramWebhookSecretToken,sendTelegramChatAction,sendTelegramMessage,splitTelegramMessageText,telegramCallbackInputResponse,telegramChannel,telegramContinuationToken,telegramReplyInputResponse,verifyTelegramRequest};

package/dist/src/public/channels/telegram/telegramChannel.d.ts

@@ -0,0 +1,126 @@
+import type { ModelMessage } from "ai";
+import type { TypedReceiveRoute } from "#channel/receive-args.js";
+import type { SessionHandle } from "#channel/session.js";
+import type { SessionAuthContext } from "#channel/types.js";
+import type { HandleMessageStreamEvent } from "#protocol/message.js";
+import { type TelegramApiOptions, type TelegramApiResponse, type TelegramCredentials, type TelegramMessageBody, type TelegramMessageResult } from "#public/channels/telegram/api.js";
+import { type TelegramHitlState } from "#public/channels/telegram/hitl.js";
+import { type TelegramCallbackQuery, type TelegramChatType, type TelegramMessage } from "#public/channels/telegram/inbound.js";
+import { type UploadPolicyInput } from "#public/channels/upload-policy.js";
+import { type TelegramWebhookSecretToken, type TelegramWebhookVerifier } from "#public/channels/telegram/verify.js";
+import { type Channel } from "#public/definitions/defineChannel.js";
+import { type JsonObject } from "#shared/json.js";
+type EventData<T extends HandleMessageStreamEvent["type"]> = Extract<HandleMessageStreamEvent, {
+    type: T;
+}> extends {
+    data: infer D;
+} ? D : undefined;
+/** Pre-dispatch Telegram context passed to inbound hooks. */
+export interface TelegramContext {
+    readonly telegram: TelegramHandle;
+}
+/** Event-handler Telegram context, including mutable per-conversation state. */
+export interface TelegramEventContext extends TelegramContext {
+    readonly session: SessionHandle;
+    state: TelegramChannelState;
+}
+/** JSON-serializable Telegram channel state. */
+export interface TelegramChannelState extends TelegramHitlState {
+    /** Telegram bot username used for group mention detection, when configured. */
+    botUsername?: string | null;
+    /** Telegram chat id. */
+    chatId: string | null;
+    /** Telegram chat type, when known from an inbound update. */
+    chatType: TelegramChatType | null;
+    /** Group/supergroup conversation anchor message id. */
+    conversationId: string | null;
+    /** Forum topic id, when known. */
+    messageThreadId: number | null;
+    /** Telegram user id that triggered the current session/turn. */
+    triggeringUserId?: string | null;
+}
+/** Telegram channel credentials. */
+export interface TelegramChannelCredentials extends TelegramCredentials {
+    /**
+     * Telegram webhook secret token configured through setWebhook.
+     * Falls back to `TELEGRAM_WEBHOOK_SECRET_TOKEN` when neither this
+     * nor `webhookVerifier` is supplied.
+     */
+    readonly webhookSecretToken?: TelegramWebhookSecretToken;
+    /** Custom inbound webhook verifier for forwarded webhooks. */
+    readonly webhookVerifier?: TelegramWebhookVerifier;
+}
+/** Arguments accepted by `receive(telegram, args)` for proactive sessions. */
+export interface TelegramReceiveArgs {
+    readonly chatId: number | string;
+    readonly conversationId?: number | string;
+    readonly initialMessage?: string | TelegramMessageBody;
+    readonly messageThreadId?: number;
+}
+/** Result of an inbound Telegram message hook. Return `null` to drop the update. */
+export type TelegramInboundResult = {
+    readonly auth: SessionAuthContext | null;
+    readonly modelContext?: readonly ModelMessage[];
+} | null;
+/** Sync or async {@link TelegramInboundResult}. */
+export type TelegramInboundResultOrPromise = TelegramInboundResult | Promise<TelegramInboundResult>;
+type TelegramEventHandler<T extends HandleMessageStreamEvent["type"]> = (data: EventData<T>, ctx: TelegramEventContext) => void | Promise<void>;
+/** Event handlers supported by `telegramChannel({ events })`. */
+export interface TelegramChannelEvents {
+    readonly "turn.started"?: TelegramEventHandler<"turn.started">;
+    readonly "actions.requested"?: TelegramEventHandler<"actions.requested">;
+    readonly "action.result"?: TelegramEventHandler<"action.result">;
+    readonly "message.completed"?: TelegramEventHandler<"message.completed">;
+    readonly "message.appended"?: TelegramEventHandler<"message.appended">;
+    readonly "input.requested"?: TelegramEventHandler<"input.requested">;
+    readonly "turn.failed"?: TelegramEventHandler<"turn.failed">;
+    readonly "turn.completed"?: TelegramEventHandler<"turn.completed">;
+    readonly "session.failed"?: TelegramEventHandler<"session.failed">;
+    readonly "session.completed"?: TelegramEventHandler<"session.completed">;
+    readonly "session.waiting"?: TelegramEventHandler<"session.waiting">;
+    readonly "connection.authorization_required"?: TelegramEventHandler<"connection.authorization_required">;
+    readonly "connection.authorization_pending"?: TelegramEventHandler<"connection.authorization_pending">;
+    readonly "connection.authorization_completed"?: TelegramEventHandler<"connection.authorization_completed">;
+}
+/** Configuration for {@link telegramChannel}. */
+export interface TelegramChannelConfig {
+    readonly api?: Omit<TelegramApiOptions, "credentials">;
+    readonly botUsername?: string;
+    readonly credentials?: TelegramChannelCredentials;
+    readonly events?: TelegramChannelEvents;
+    /** Handler for non-HITL callback queries. */
+    readonly onCallbackQuery?: (ctx: TelegramContext, query: TelegramCallbackQuery) => void | Promise<void>;
+    /** Inbound message hook. Defaults to Telegram user auth and dispatch gating. */
+    readonly onMessage?: (ctx: TelegramContext, message: TelegramMessage) => TelegramInboundResultOrPromise;
+    /** Override the default webhook route path (`/ash/v1/telegram`). */
+    readonly route?: string;
+    /** Inbound upload policy for Telegram photos and documents. */
+    readonly uploadPolicy?: UploadPolicyInput;
+}
+/** Low-level Telegram handle exposed to hooks and event handlers. */
+export interface TelegramHandle {
+    readonly botUsername: string | undefined;
+    readonly chatId: string;
+    readonly chatType: TelegramChatType | undefined;
+    readonly conversationId: string | undefined;
+    readonly messageThreadId: number | undefined;
+    request(method: string, body?: JsonObject): Promise<TelegramApiResponse>;
+    post(message: string | TelegramMessageBody): Promise<TelegramMessageResult>;
+    sendMessage(message: string | TelegramMessageBody): Promise<TelegramMessageResult>;
+    startTyping(action?: string): Promise<void>;
+    answerCallbackQuery(input: {
+        readonly callbackQueryId: string;
+        readonly showAlert?: boolean;
+        readonly text?: string;
+    }): Promise<TelegramApiResponse>;
+    editMessageReplyMarkup(input: {
+        readonly messageId: number | string;
+        readonly replyMarkup?: Readonly<Record<string, unknown>>;
+    }): Promise<TelegramApiResponse>;
+}
+/** Concrete return type of {@link telegramChannel}. */
+export interface TelegramChannel extends Channel<TelegramChannelState>, TypedReceiveRoute<TelegramReceiveArgs> {
+}
+/** Telegram channel factory for webhook updates and proactive messages. */
+export declare function telegramChannel(config?: TelegramChannelConfig): TelegramChannel;
+export {};

package/dist/src/public/channels/telegram/telegramChannel.js

@@ -0,0 +1 @@
+import{createLogger}from"#internal/logging.js";import{isCompiledChannel}from"#channel/compiled-channel.js";import{parseJsonObject}from"#shared/json.js";import{defaultDeliverResult}from"#channel/adapter.js";import{mergeUploadPolicy}from"#public/channels/upload-policy.js";import{POST,defineChannel}from"#public/definitions/defineChannel.js";import{answerTelegramCallbackQuery,callTelegramApi,editTelegramMessageReplyMarkup,sendTelegramChatAction,sendTelegramMessage,splitTelegramMessageText,telegramContinuationToken}from"#public/channels/telegram/api.js";import{TELEGRAM_HITL_CALLBACK_PREFIX,isTelegramSyntheticResponse,resolveTelegramInputResponses,telegramCallbackInputResponse,telegramReplyInputResponse}from"#public/channels/telegram/hitl.js";import{parseTelegramUpdate,prependTelegramContext}from"#public/channels/telegram/inbound.js";import{buildTelegramTurnMessage,collectTelegramFileParts,createTelegramFetchFile}from"#public/channels/telegram/attachments.js";import{defaultEvents,defaultOnMessage}from"#public/channels/telegram/defaults.js";import{verifyTelegramRequest}from"#public/channels/telegram/verify.js";var log=createLogger(`telegram.channel`);function telegramChannel(e={}){let t=mergeUploadPolicy(e.uploadPolicy),r=e.onMessage??defaultOnMessage,s={...defaultEvents,...e.events},c=defineChannel({kindHint:`telegram`,state:initialTelegramState(e.botUsername),fetchFile:createTelegramFetchFile({api:e.api,credentials:e.credentials,policy:t}),context(t,n){return rebuildTelegramContext(t,n,e)},routes:[POST(e.route??`/ash/v1/telegram`,async(i,{send:a,waitUntil:o})=>{let s=await verifyInbound(i,e.credentials);if(s===null)return new Response(`unauthorized`,{status:401});let c;try{c=parseJsonObject(JSON.parse(s))}catch(e){return log.warn(`inbound Telegram body is not valid JSON`,{error:e}),new Response(`ok`)}let l=parseTelegramUpdate(c);return l===null?new Response(`ok`):l.kind===`message`?(o(dispatchMessage({config:e,message:l.message,onMessage:r,send:a,uploadPolicy:t})),new Response(`ok`)):(o(dispatchCallbackQuery({config:e,query:l.callbackQuery,send:a})),new Response(`ok`))})],async receive(t,{send:n}){let r=t.args,i=readChatId(r.chatId);if(i===void 0)throw Error(`telegramChannel().receive requires args.chatId.`);let a=typeof r.messageThreadId==`number`?r.messageThreadId:void 0,o=readOptionalString(r.conversationId),s=r.initialMessage;if(s!==void 0&&o!==void 0)throw Error("telegramChannel().receive: `conversationId` and `initialMessage` are mutually exclusive.");let c=o;return s!==void 0&&(c=(await buildTelegramHandle({config:e,state:{...initialTelegramState(e.botUsername),chatId:i,messageThreadId:a??null}}).sendMessage(s)).id||void 0),n(t.message,{auth:t.auth,continuationToken:telegramContinuationToken({chatId:i,conversationId:c,messageThreadId:a}),state:{...initialTelegramState(e.botUsername),chatId:i,conversationId:c??null,messageThreadId:a??null}})},events:s});return attachTelegramDeliver(c),c}function rebuildTelegramContext(e,t,n){return{session:t,state:e,telegram:buildTelegramHandle({config:n,session:t,state:e})}}function buildTelegramHandle(e){let t=e.config.api,n=e.state,r=e.config.credentials;function anchor(t){!t.id||n.chatType===`private`||(n.conversationId=t.id,n.chatId&&e.session?.setContinuationToken(telegramContinuationToken({chatId:n.chatId,conversationId:t.id,messageThreadId:n.messageThreadId??void 0})))}async function sendOne(e){let i=n.chatId??``;if(!i)throw Error(`telegramChannel: missing chat id for outbound message.`);let a=await sendTelegramMessage({apiBaseUrl:t?.apiBaseUrl,body:{...e,message_thread_id:e.message_thread_id??n.messageThreadId??void 0},credentials:r,fetch:t?.fetch,fileBaseUrl:t?.fileBaseUrl,chatId:i});return anchor(a),a}return{botUsername:n.botUsername??e.config.botUsername,chatId:n.chatId??``,chatType:n.chatType??void 0,conversationId:n.conversationId??void 0,messageThreadId:n.messageThreadId??void 0,answerCallbackQuery(e){return answerTelegramCallbackQuery({apiBaseUrl:t?.apiBaseUrl,callbackQueryId:e.callbackQueryId,credentials:r,fetch:t?.fetch,showAlert:e.showAlert,text:e.text})},editMessageReplyMarkup(e){let i=n.chatId??``;if(!i)throw Error(`telegramChannel: missing chat id for reply-markup edit.`);return editTelegramMessageReplyMarkup({apiBaseUrl:t?.apiBaseUrl,chatId:i,credentials:r,fetch:t?.fetch,messageId:e.messageId,replyMarkup:e.replyMarkup})},post(e){return postTelegramMessage(e,sendOne)},request(e,n){return callTelegramApi({apiBaseUrl:t?.apiBaseUrl,body:n,botToken:r?.botToken,fetch:t?.fetch,method:e})},sendMessage(e){return postTelegramMessage(e,sendOne)},async startTyping(e=`typing`){let i=n.chatId??``;if(i)try{await sendTelegramChatAction({action:e,apiBaseUrl:t?.apiBaseUrl,chatId:i,credentials:r,fetch:t?.fetch,messageThreadId:n.messageThreadId??void 0})}catch(e){log.debug(`Telegram typing indicator failed — swallowed`,{error:e})}}}}async function postTelegramMessage(e,t){let n=typeof e==`string`?{text:e}:e,r=splitTelegramMessageText(n.text),i;for(let[e,a]of r.entries()){let r=await t(e===0?{...n,text:a}:{text:a});i===void 0&&(i=r)}return i??{id:``,raw:null}}async function verifyInbound(e,t){try{return await verifyTelegramRequest(e,{secretToken:t?.webhookVerifier?void 0:t?.webhookSecretToken,webhookVerifier:t?.webhookVerifier})}catch(e){return log.warn(`telegram inbound verification failed`,{error:e}),null}}async function dispatchMessage(e){if(e.message.from?.isBot===!0)return;let t=stateFromMessage(e.message,e.config),n={telegram:buildTelegramHandle({config:e.config,state:t})},r;try{r=await e.onMessage(n,e.message)}catch(e){log.error(`message handler failed`,{error:e});return}if(r==null)return;let i=collectTelegramFileParts(e.message.attachments,e.uploadPolicy),a=prependTelegramContext(buildTelegramTurnMessage(e.message,i),{botUsername:e.config.botUsername,chatId:e.message.chat.id,chatTitle:e.message.chat.title,chatType:e.message.chat.type,messageId:e.message.messageId,messageThreadId:e.message.messageThreadId,userId:e.message.from?.id,username:e.message.from?.username}),o=e.message.text||e.message.caption,s=e.message.replyToMessage?.from?.isBot===!0&&o.trim().length>0?[telegramReplyInputResponse({messageId:e.message.replyToMessage.messageId,text:o})]:void 0;try{await e.send({inputResponses:s,message:a,modelContext:r.modelContext},{auth:r.auth,continuationToken:continuationTokenFromState(t),state:t})}catch(e){log.error(`message delivery failed`,{error:e})}}async function dispatchCallbackQuery(e){let t=stateFromCallbackQuery(e.query,e.config),n={telegram:buildTelegramHandle({config:e.config,state:t})};if(e.query.data?.startsWith(TELEGRAM_HITL_CALLBACK_PREFIX)===!0){try{await n.telegram.answerCallbackQuery({callbackQueryId:e.query.id,text:`Answer received.`})}catch(e){log.warn(`Telegram callback-query acknowledgement failed`,{error:e})}if(!e.query.message||!t.chatId)return;try{await e.send({inputResponses:[telegramCallbackInputResponse(e.query.data)]},{auth:null,continuationToken:continuationTokenFromState(t),state:t})}catch(e){log.error(`callback query delivery failed`,{error:e})}return}if(e.config.onCallbackQuery!==void 0){try{await e.config.onCallbackQuery(n,e.query)}catch(e){log.error(`custom callback-query handler failed`,{error:e})}return}try{await n.telegram.answerCallbackQuery({callbackQueryId:e.query.id,text:`Unsupported action.`})}catch(e){log.warn(`Telegram unsupported callback-query acknowledgement failed`,{error:e})}}function attachTelegramDeliver(e){if(!isCompiledChannel(e))return;let n=e.adapter;n.deliver=(e,t)=>{let n=e.inputResponses??[];if(n.some(isTelegramSyntheticResponse)){let r=resolveTelegramInputResponses(t.state,n);return r.length>0?{inputResponses:r,modelContext:e.modelContext}:e.message===void 0?void 0:{message:e.message,modelContext:e.modelContext}}return defaultDeliverResult(e)}}function stateFromMessage(e,t){let n=e.chat.type===`private`;return{...initialTelegramState(t.botUsername),chatId:e.chat.id,chatType:e.chat.type,conversationId:n?null:conversationIdForMessage(e),messageThreadId:e.messageThreadId??null,triggeringUserId:e.from?.id??null}}function stateFromCallbackQuery(e,t){let n=e.message;if(!n)return{...initialTelegramState(t.botUsername),triggeringUserId:e.from.id};let r=n.chat.type===`private`;return{...initialTelegramState(t.botUsername),chatId:n.chat.id,chatType:n.chat.type,conversationId:r?null:n.messageId,messageThreadId:n.messageThreadId??null,triggeringUserId:e.from.id}}function conversationIdForMessage(e){return e.replyToMessage?.from?.isBot===!0?e.replyToMessage.messageId:e.messageId}function continuationTokenFromState(e){return telegramContinuationToken({chatId:e.chatId??``,conversationId:e.chatType===`private`?void 0:e.conversationId??void 0,messageThreadId:e.messageThreadId??void 0})}function initialTelegramState(e){return{botUsername:e??null,chatId:null,chatType:null,conversationId:null,hitlCallbacks:{},messageThreadId:null,nextHitlCallbackId:0,pendingFreeformReplies:{},triggeringUserId:null}}function readChatId(e){if(typeof e==`string`&&e.length>0)return e;if(typeof e==`number`&&Number.isFinite(e))return String(e)}function readOptionalString(e){if(typeof e==`string`&&e.length>0)return e;if(typeof e==`number`&&Number.isFinite(e))return String(e)}export{telegramChannel};

package/dist/src/public/channels/telegram/verify.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Telegram inbound-webhook verification.
+ *
+ * When a webhook is configured with `secret_token`, Telegram includes
+ * that exact value in `X-Telegram-Bot-Api-Secret-Token` for every
+ * webhook request. The native channel verifies the header directly or
+ * delegates to a caller-supplied verifier for forwarded webhooks.
+ */
+/** Secret token configured on Telegram's `setWebhook` call. */
+export type TelegramWebhookSecretToken = string | (() => string | Promise<string>);
+/**
+ * Caller-supplied inbound webhook verifier. Used as an alternative to
+ * Telegram's secret-token header when an integration authenticates
+ * forwarded webhooks before they reach Ash.
+ */
+export type TelegramWebhookVerifier = (request: Request, body: string) => unknown | Promise<unknown>;
+/** Options for {@link verifyTelegramRequest}. */
+export interface TelegramVerifyOptions {
+    readonly secretToken: TelegramWebhookSecretToken | undefined;
+    readonly webhookVerifier?: TelegramWebhookVerifier;
+}
+/** Resolves a Telegram webhook secret, falling back to `TELEGRAM_WEBHOOK_SECRET_TOKEN`. */
+export declare function resolveTelegramWebhookSecretToken(secretToken?: TelegramWebhookSecretToken): Promise<string>;
+/**
+ * Verifies an inbound Telegram webhook and returns its raw body.
+ *
+ * Throws when no secret/verifier is configured, the secret header is
+ * missing, or the supplied verifier/header rejects.
+ */
+export declare function verifyTelegramRequest(request: Request, options: TelegramVerifyOptions): Promise<string>;

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

@@ -0,0 +1 @@
+import{createLogger}from"#internal/logging.js";import{timingSafeEqual}from"node:crypto";var log=createLogger(`telegram.verify`);async function resolveTelegramWebhookSecretToken(e){let t=e??process.env.TELEGRAM_WEBHOOK_SECRET_TOKEN;if(!t)throw Error(`TELEGRAM_WEBHOOK_SECRET_TOKEN is required.`);return typeof t==`function`?await t():t}async function verifyTelegramRequest(e,t){let n=await e.text();if(t.webhookVerifier!==void 0){let r=await t.webhookVerifier(e,n);if(!r)throw Error(`telegramChannel: inbound webhook verifier rejected the request.`);return typeof r==`string`?r:n}let r=await resolveTelegramWebhookSecretToken(t.secretToken),i=e.headers.get(`x-telegram-bot-api-secret-token`)??``;if(!i)throw Error(`telegramChannel: inbound request missing Telegram secret-token header.`);if(!constantTimeCompare(r,i))throw Error(`telegramChannel: inbound request secret-token mismatch.`);return n}function constantTimeCompare(e,r){if(e.length!==r.length)return!1;try{return timingSafeEqual(Buffer.from(e),Buffer.from(r))}catch(e){return log.debug(`timingSafeEqual threw`,{error:e}),!1}}export{resolveTelegramWebhookSecretToken,verifyTelegramRequest};

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};

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};