experimental-ash 0.27.0 → 0.28.0

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

@@ -0,0 +1,23 @@
+import type { FilePart, UserContent } from "ai";
+import type { FetchFileResult } from "#channel/adapter.js";
+import { type TelegramApiOptions } from "#public/channels/telegram/api.js";
+import type { TelegramAttachment, TelegramMessage } from "#public/channels/telegram/inbound.js";
+import { type UploadPolicy } from "#public/channels/upload-policy.js";
+/** URL protocol used by the channel to defer Telegram file downloads to `fetchFile`. */
+export declare const TELEGRAM_FILE_URL_PROTOCOL = "telegram-file:";
+/** Emits one {@link FilePart} per supported Telegram attachment. */
+export declare function collectTelegramFileParts(attachments: readonly TelegramAttachment[], policy: UploadPolicy): FilePart[];
+/** Combines text/caption + file parts into the {@link UserContent} shape the harness expects. */
+export declare function buildTelegramTurnMessage(message: Pick<TelegramMessage, "caption" | "text">, fileParts: readonly FilePart[]): string | UserContent;
+/** Creates a `fetchFile` function for Telegram-owned file URLs. */
+export declare function createTelegramFetchFile(input: {
+    readonly api?: Omit<TelegramApiOptions, "credentials">;
+    readonly credentials?: TelegramApiOptions["credentials"];
+    readonly policy: UploadPolicy;
+}): (url: string) => Promise<FetchFileResult | null>;
+/** Builds the internal URL used to defer a Telegram file download. */
+export declare function createTelegramFileUrl(input: {
+    readonly fileId: string;
+    readonly filename?: string;
+    readonly mediaType?: string;
+}): URL;

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

@@ -0,0 +1 @@
+import{createLogger}from"#internal/logging.js";import{evaluateFilePart,formatUploadPolicyViolation,isMediaTypeAllowed,isUploadsDisabled}from"#public/channels/upload-policy.js";import{downloadTelegramFile,getTelegramFile}from"#public/channels/telegram/api.js";var log=createLogger(`telegram.attachments`),TELEGRAM_FILE_URL_PROTOCOL=`telegram-file:`;function collectTelegramFileParts(e,t){if(isUploadsDisabled(t))return[];let r=[];for(let i of e){let e=toTelegramFilePart(i,r.length);if(e===null)continue;let a=evaluateTelegramFilePart(e,i.size,t);if(a!==null){log.warn(`dropped attachment — ${formatUploadPolicyViolation(a)}`,{fileId:i.fileId,name:i.fileName});continue}r.push(e)}return r}function buildTelegramTurnMessage(e,t){let n=e.text||e.caption;return t.length===0?n:n.trim().length===0?[...t]:[{type:`text`,text:n},...t]}function createTelegramFetchFile(e){return async r=>{let i=parseTelegramFileUrl(r);if(i===null)return null;let o=await getTelegramFile({apiBaseUrl:e.api?.apiBaseUrl,credentials:e.credentials,fetch:e.api?.fetch,fileId:i.fileId}),s=await downloadTelegramFile({apiBaseUrl:e.api?.apiBaseUrl,credentials:e.credentials,fetch:e.api?.fetch,fileBaseUrl:e.api?.fileBaseUrl,filePath:o.filePath});if(!s.ok)throw Error(`Telegram file fetch returned HTTP ${s.status} for ${r}.`);let c=Buffer.from(await s.arrayBuffer()),l=s.headers.get(`content-type`)??i.mediaType??`application/octet-stream`,u={bytes:c,filename:i.filename,mediaType:l},d=evaluateFilePart({data:u.bytes,filename:u.filename,mediaType:l,type:`file`},e.policy);if(d!==null)throw Error(`Telegram file rejected — ${formatUploadPolicyViolation(d)}`);return u}}function createTelegramFileUrl(e){let t=new URLSearchParams;e.filename!==void 0&&t.set(`filename`,e.filename),e.mediaType!==void 0&&t.set(`mediaType`,e.mediaType);let n=t.size>0?`?${t.toString()}`:``;return new URL(`${TELEGRAM_FILE_URL_PROTOCOL}${encodeURIComponent(e.fileId)}${n}`)}function toTelegramFilePart(e,t){let n=e.mediaType??(e.kind===`photo`?`image/jpeg`:`application/octet-stream`),r=e.fileName??(e.kind===`photo`?`photo-${t}.jpg`:`file-${t}`);return{data:createTelegramFileUrl({fileId:e.fileId,filename:r,mediaType:n}),filename:r,mediaType:n,type:`file`}}function parseTelegramFileUrl(e){let t;try{t=new URL(e)}catch{return null}if(t.protocol!==`telegram-file:`)return null;let n=decodeURIComponent(t.pathname);return n?{fileId:n,filename:t.searchParams.get(`filename`)??void 0,mediaType:t.searchParams.get(`mediaType`)??void 0}:null}function evaluateTelegramFilePart(e,n,i){return i===`disabled`||!isMediaTypeAllowed(e.mediaType,i)?evaluateFilePart(e,i):n!==void 0&&n>i.maxBytes?{byteLength:n,filename:e.filename,kind:`too-large`,limit:i.maxBytes,mediaType:e.mediaType}:null}export{TELEGRAM_FILE_URL_PROTOCOL,buildTelegramTurnMessage,collectTelegramFileParts,createTelegramFetchFile,createTelegramFileUrl};

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

@@ -0,0 +1,9 @@
+import type { SessionAuthContext } from "#channel/types.js";
+import type { TelegramMessage } from "#public/channels/telegram/inbound.js";
+import type { TelegramChannelEvents, TelegramContext, TelegramInboundResult } from "#public/channels/telegram/telegramChannel.js";
+/** Default auth projection for Telegram webhook actors. */
+export declare function defaultTelegramAuth(message: TelegramMessage): SessionAuthContext | null;
+/** Default inbound message hook: dispatch allowed messages with Telegram user auth. */
+export declare function defaultOnMessage(ctx: TelegramContext, message: TelegramMessage): Promise<TelegramInboundResult>;
+/** Built-in Telegram event handlers for typing, replies, HITL, and terminal errors. */
+export declare const defaultEvents: TelegramChannelEvents;

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

@@ -0,0 +1,3 @@
+import{extractErrorId,formatErrorHint}from"#internal/logging.js";import{registerTelegramFreeformPrompt,renderTelegramInputRequest}from"#public/channels/telegram/hitl.js";function defaultTelegramAuth(e){let t=e.from;if(!t)return null;let n={chat_id:e.chat.id,chat_type:e.chat.type,message_id:e.messageId,user_id:t.id};e.chat.title!==void 0&&(n.chat_title=e.chat.title),e.messageThreadId!==void 0&&(n.message_thread_id=String(e.messageThreadId)),t.username!==void 0&&(n.username=t.username);let r=e.chat.type===`group`||e.chat.type===`supergroup`,i=r?`telegram:${e.chat.id}:${t.id}`:`telegram:${t.id}`;return{attributes:n,authenticator:`telegram-webhook`,issuer:r?`telegram:${e.chat.id}`:`telegram`,principalId:i,principalType:t.isBot?`service`:`user`}}async function defaultOnMessage(e,t){return shouldDispatchTelegramMessage(t,e.telegram.botUsername)?(await e.telegram.startTyping(),{auth:defaultTelegramAuth(t)}):null}var defaultEvents={async"turn.started"(e,t){await t.telegram.startTyping()},async"actions.requested"(e,t){await t.telegram.startTyping()},async"input.requested"(e,t){for(let i of e.requests){let e=renderTelegramInputRequest(i,t.state),a=await t.telegram.post({reply_markup:e.replyMarkup,text:e.text});e.freeformRequestId!==void 0&&a.id&&registerTelegramFreeformPrompt(t.state,{messageId:a.id,requestId:e.freeformRequestId})}},async"message.completed"(e,t){e.finishReason===`tool-calls`||!e.message||await t.telegram.post(e.message)},async"turn.failed"(n,r){let i=formatErrorHint(n),a=extractErrorId(n.details);await r.telegram.post([`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.telegram.post([`This session could not recover from an error${i}.`,``,`Start a new message to continue.`,...a?[``,`Error id: ${a}`]:[]].join(`
+`))}};function shouldDispatchTelegramMessage(e,t){if(e.from?.isBot===!0||e.chat.type===`channel`)return!1;let n=e.text||e.caption;return n.trim().length>0||e.attachments.length>0?!!(e.chat.type===`private`||e.replyToMessage?.from?.isBot===!0||isBotCommand(n,t)||t!==void 0&&mentionsBot(n,t)):!1}function isBotCommand(e,t){let n=/^\/(?<command>[A-Za-z0-9_]+)(?:@(?<target>[A-Za-z0-9_]+))?(?:\s|$)/u.exec(e);if(!n)return!1;let r=n.groups?.target;return r===void 0?!0:t!==void 0&&r.toLowerCase()===t.toLowerCase()}function mentionsBot(e,t){return e.toLowerCase().includes(`@${t.toLowerCase()}`)}export{defaultEvents,defaultOnMessage,defaultTelegramAuth};

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

@@ -0,0 +1,44 @@
+/**
+ * Telegram HITL inline keyboard rendering + compact callback decode helpers.
+ *
+ * Telegram limits `InlineKeyboardButton.callback_data` to 64 bytes, so
+ * Ash stores compact callback ids in durable channel state and remaps
+ * them back to full input responses inside the channel deliver hook.
+ */
+import type { InputRequest, InputResponse } from "#runtime/input/types.js";
+/** Prefix used in Telegram callback_data values generated by Ash. */
+export declare const TELEGRAM_HITL_CALLBACK_PREFIX = "ash:";
+/** Synthetic request id prefix sent through `send()` for callback queries. */
+export declare const TELEGRAM_CALLBACK_RESPONSE_PREFIX = "telegram_callback:";
+/** Synthetic request id prefix sent through `send()` for replies to ForceReply prompts. */
+export declare const TELEGRAM_REPLY_RESPONSE_PREFIX = "telegram_reply:";
+/** Minimal durable state shape used by the HITL helpers. */
+export interface TelegramHitlState {
+    hitlCallbacks?: Record<string, InputResponse>;
+    nextHitlCallbackId?: number;
+    pendingFreeformReplies?: Record<string, string>;
+}
+/** Rendered Telegram message body for one pending input request. */
+export interface TelegramInputRequestMessage {
+    readonly freeformRequestId?: string;
+    readonly replyMarkup?: Readonly<Record<string, unknown>>;
+    readonly text: string;
+}
+/** Renders one `InputRequest` as Telegram inline keyboard or ForceReply markup. */
+export declare function renderTelegramInputRequest(request: InputRequest, state: TelegramHitlState): TelegramInputRequestMessage;
+/** Records the Telegram message id that a freeform answer should reply to. */
+export declare function registerTelegramFreeformPrompt(state: TelegramHitlState, input: {
+    readonly messageId: string;
+    readonly requestId: string;
+}): void;
+/** Wraps Telegram callback data in an `InputResponse` shape for delivery. */
+export declare function telegramCallbackInputResponse(callbackData: string): InputResponse;
+/** Wraps a reply-to-message id in an `InputResponse` shape for delivery. */
+export declare function telegramReplyInputResponse(input: {
+    readonly messageId: string;
+    readonly text: string;
+}): InputResponse;
+/** True when an input response needs Telegram-specific durable-state remapping. */
+export declare function isTelegramSyntheticResponse(response: InputResponse): boolean;
+/** Remaps compact Telegram callback/reply ids into real Ash input responses. */
+export declare function resolveTelegramInputResponses(state: TelegramHitlState, responses: readonly InputResponse[]): InputResponse[];

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

@@ -0,0 +1 @@
+var TELEGRAM_HITL_CALLBACK_PREFIX=`ash:`,TELEGRAM_CALLBACK_RESPONSE_PREFIX=`telegram_callback:`,TELEGRAM_REPLY_RESPONSE_PREFIX=`telegram_reply:`,TELEGRAM_BUTTON_LABEL_MAX_LENGTH=64,TELEGRAM_INPUT_PLACEHOLDER_MAX_LENGTH=64,TELEGRAM_PROMPT_MAX_LENGTH=4e3,TELEGRAM_INLINE_ROW_SIZE=2;function renderTelegramInputRequest(e,t){let n=e.options;return n&&n.length>0?{replyMarkup:{inline_keyboard:chunk(n.map(n=>({callback_data:registerTelegramCallback(t,{optionId:n.id,requestId:e.requestId}),text:truncate(n.label,TELEGRAM_BUTTON_LABEL_MAX_LENGTH)})),TELEGRAM_INLINE_ROW_SIZE)},text:truncate(e.prompt,TELEGRAM_PROMPT_MAX_LENGTH)}:{freeformRequestId:e.requestId,replyMarkup:{force_reply:!0,input_field_placeholder:truncate(`Type your answer`,TELEGRAM_INPUT_PLACEHOLDER_MAX_LENGTH),selective:!0},text:truncate(e.prompt,TELEGRAM_PROMPT_MAX_LENGTH)}}function registerTelegramFreeformPrompt(e,t){e.pendingFreeformReplies={...e.pendingFreeformReplies,[t.messageId]:t.requestId}}function telegramCallbackInputResponse(e){return{optionId:`selected`,requestId:`${TELEGRAM_CALLBACK_RESPONSE_PREFIX}${e}`}}function telegramReplyInputResponse(e){return{requestId:`${TELEGRAM_REPLY_RESPONSE_PREFIX}${e.messageId}`,text:e.text}}function isTelegramSyntheticResponse(e){return e.requestId.startsWith(`telegram_callback:`)||e.requestId.startsWith(`telegram_reply:`)}function resolveTelegramInputResponses(e,r){let i=[];for(let a of r){if(a.requestId.startsWith(`telegram_callback:`)){let n=a.requestId.slice(TELEGRAM_CALLBACK_RESPONSE_PREFIX.length),r=e.hitlCallbacks?.[n];r!==void 0&&(i.push(r),delete e.hitlCallbacks?.[n]);continue}if(a.requestId.startsWith(`telegram_reply:`)){let t=a.requestId.slice(TELEGRAM_REPLY_RESPONSE_PREFIX.length),r=e.pendingFreeformReplies?.[t];r!==void 0&&a.text!==void 0&&(i.push({requestId:r,text:a.text}),delete e.pendingFreeformReplies?.[t]);continue}i.push(a)}return i}function registerTelegramCallback(t,n){let r=t.nextHitlCallbackId??0;t.nextHitlCallbackId=r+1;let i=`${TELEGRAM_HITL_CALLBACK_PREFIX}${r.toString(36)}`;return t.hitlCallbacks={...t.hitlCallbacks,[i]:n},i}function truncate(e,t){if(e.length<=t)return e;let n=Math.max(0,t-3);return`${e.slice(0,n).trimEnd()}...`}function chunk(e,t){let n=[];for(let r=0;r<e.length;r+=t)n.push(e.slice(r,r+t));return n}export{TELEGRAM_CALLBACK_RESPONSE_PREFIX,TELEGRAM_HITL_CALLBACK_PREFIX,TELEGRAM_REPLY_RESPONSE_PREFIX,isTelegramSyntheticResponse,registerTelegramFreeformPrompt,renderTelegramInputRequest,resolveTelegramInputResponses,telegramCallbackInputResponse,telegramReplyInputResponse};

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "experimental-ash",
-  "version": "0.27.0",
+  "version": "0.28.0",
   "bin": {
     "ash": "./bin/ash.js",
     "experimental-ash": "./bin/ash.js"
@@ -156,6 +156,16 @@
       "import": "./dist/src/public/channels/twilio/index.js",
       "default": "./dist/src/public/channels/twilio/index.js"
     },
+    "./channels/telegram": {
+      "types": "./dist/src/public/channels/telegram/index.d.ts",
+      "import": "./dist/src/public/channels/telegram/index.js",
+      "default": "./dist/src/public/channels/telegram/index.js"
+    },
+    "./channels/teams": {
+      "types": "./dist/src/public/channels/teams/index.d.ts",
+      "import": "./dist/src/public/channels/teams/index.js",
+      "default": "./dist/src/public/channels/teams/index.js"
+    },
     "./package.json": "./package.json"
   },
   "publishConfig": {