@poncho-ai/messaging 0.2.8 → 0.3.0

package/.turbo/turbo-build.log

@@ -1,5 +1,5 @@
 
-> @poncho-ai/messaging@0.2.8 build /home/runner/work/poncho-ai/poncho-ai/packages/messaging
+> @poncho-ai/messaging@0.3.0 build /Users/cesar/Dev/latitude/poncho-ai/packages/messaging
 > tsup src/index.ts --format esm --dts
 
 CLI Building entry: src/index.ts
@@ -7,8 +7,8 @@
 CLI tsup v8.5.1
 CLI Target: es2022
 ESM Build start
-ESM dist/index.js 30.13 KB
-ESM ⚡️ Build success in 77ms
+ESM dist/index.js 44.67 KB
+ESM ⚡️ Build success in 55ms
 DTS Build start
-DTS ⚡️ Build success in 5331ms
-DTS dist/index.d.ts 8.98 KB
+DTS ⚡️ Build success in 3450ms
+DTS dist/index.d.ts 9.98 KB

package/.turbo/turbo-test.log

@@ -0,0 +1,29 @@
+
+> @poncho-ai/messaging@0.2.4 test /Users/cesar/Dev/latitude/poncho-ai/packages/messaging
+> vitest
+
+
+ RUN  v1.6.1 /Users/cesar/Dev/latitude/poncho-ai/packages/messaging
+
+stderr | test/bridge.test.ts > AgentBridge > posts an error message and cleans up on runner failure
+[agent-bridge] handleMessage error: Model overloaded
+
+stderr | test/bridge.test.ts > AgentBridge > skips sendReply when autoReply is false
+[agent-bridge] tool mode completed without send_email being called; no reply sent
+
+stderr | test/bridge.test.ts > AgentBridge > suppresses error reply when hasSentInCurrentRequest is true
+[agent-bridge] handleMessage error: Oops
+
+stderr | test/bridge.test.ts > AgentBridge > calls resetRequestState before handling each message
+[agent-bridge] tool mode completed without send_email being called; no reply sent
+
+ ✓ test/bridge.test.ts  (15 tests) 7ms
+ ✓ test/adapters/email-utils.test.ts  (44 tests) 13ms
+ ✓ test/adapters/resend.test.ts  (13 tests) 7ms
+ ✓ test/adapters/slack.test.ts  (17 tests) 61ms
+
+ Test Files  4 passed (4)
+      Tests  89 passed (89)
+   Start at  17:47:42
+   Duration  442ms (transform 223ms, setup 0ms, collect 336ms, tests 88ms, environment 0ms, prepare 304ms)
+

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # @poncho-ai/messaging
 
+## 0.3.0
+
+### Minor Changes
+
+- [`de28ef5`](https://github.com/cesr/poncho-ai/commit/de28ef5acceed921269d15816acd392f5208f03d) Thanks [@cesr](https://github.com/cesr)! - Add Telegram messaging adapter with private/group chat support, file attachments, /new command, and typing indicators.
+
+### Patch Changes
+
+- Updated dependencies [[`de28ef5`](https://github.com/cesr/poncho-ai/commit/de28ef5acceed921269d15816acd392f5208f03d)]:
+  - @poncho-ai/sdk@1.4.1
+
+## 0.2.9
+
+### Patch Changes
+
+- [`e9b801f`](https://github.com/cesr/poncho-ai/commit/e9b801f0c70ffab6cb434b7adf05df22b29ea9fe) Thanks [@cesr](https://github.com/cesr)! - Derive deterministic UUIDs for messaging conversation IDs instead of composite strings. Fixes Latitude telemetry rejection and ensures consistency with web UI/API conversations.
+
 ## 0.2.8
 
 ### Patch Changes

package/dist/index.d.ts

@@ -189,6 +189,36 @@ declare class ResendAdapter implements MessagingAdapter {
     private fetchAndDownloadAttachments;
 }
 
+interface TelegramAdapterOptions {
+    botTokenEnv?: string;
+    webhookSecretEnv?: string;
+}
+declare class TelegramAdapter implements MessagingAdapter {
+    readonly platform: "telegram";
+    readonly autoReply = true;
+    readonly hasSentInCurrentRequest = false;
+    private botToken;
+    private webhookSecret;
+    private botUsername;
+    private botId;
+    private readonly botTokenEnv;
+    private readonly webhookSecretEnv;
+    private handler;
+    private readonly sessionCounters;
+    private lastUpdateId;
+    constructor(options?: TelegramAdapterOptions);
+    initialize(): Promise<void>;
+    onMessage(handler: IncomingMessageHandler): void;
+    registerRoutes(router: RouteRegistrar): void;
+    sendReply(threadRef: ThreadRef, content: string, options?: {
+        files?: FileAttachment[];
+    }): Promise<void>;
+    indicateProcessing(threadRef: ThreadRef): Promise<() => Promise<void>>;
+    private handleRequest;
+    private sessionKey;
+    private extractFiles;
+}
+
 /** Extract the bare email address from a formatted string like `"Name <addr>"`. */
 declare function extractEmailAddress(formatted: string): string;
 /** Extract the display name from `"Name <addr>"`, or return `undefined`. */
@@ -241,4 +271,4 @@ declare function markdownToEmailHtml(text: string): string;
  */
 declare function matchesSenderPattern(sender: string, patterns: string[] | undefined): boolean;
 
-export { AgentBridge, type AgentBridgeOptions, type AgentRunner, type FileAttachment, type IncomingMessage, type IncomingMessageHandler, type MessagingAdapter, ResendAdapter, type ResendAdapterOptions, type RouteHandler, type RouteRegistrar, SlackAdapter, type SlackAdapterOptions, type ThreadRef, buildReplyHeaders, buildReplySubject, deriveRootMessageId, extractDisplayName, extractEmailAddress, markdownToEmailHtml, matchesSenderPattern, parseReferences, stripQuotedReply };
+export { AgentBridge, type AgentBridgeOptions, type AgentRunner, type FileAttachment, type IncomingMessage, type IncomingMessageHandler, type MessagingAdapter, ResendAdapter, type ResendAdapterOptions, type RouteHandler, type RouteRegistrar, SlackAdapter, type SlackAdapterOptions, TelegramAdapter, type TelegramAdapterOptions, type ThreadRef, buildReplyHeaders, buildReplySubject, deriveRootMessageId, extractDisplayName, extractEmailAddress, markdownToEmailHtml, matchesSenderPattern, parseReferences, stripQuotedReply };

package/dist/index.js

@@ -1,5 +1,16 @@
 // src/bridge.ts
-var conversationIdFromThread = (platform, ref) => `${platform}:${ref.channelId}:${ref.platformThreadId}`;
+import { createHash } from "crypto";
+var conversationIdFromThread = (platform, ref) => {
+  const key = `${platform}:${ref.channelId}:${ref.platformThreadId}`;
+  const hex = createHash("sha256").update(key).digest("hex").slice(0, 32);
+  return [
+    hex.slice(0, 8),
+    hex.slice(8, 12),
+    `4${hex.slice(13, 16)}`,
+    (parseInt(hex.slice(16, 18), 16) & 63 | 128).toString(16).padStart(2, "0") + hex.slice(18, 20),
+    hex.slice(20, 32)
+  ].join("-");
+};
 var AgentBridge = class {
   adapter;
   runner;
@@ -30,9 +41,11 @@ var AgentBridge = class {
         message.platform,
         message.threadRef
       );
-      const titleParts = [message.sender.id];
+      const platformTag = `[${message.platform.charAt(0).toUpperCase()}${message.platform.slice(1)}]`;
+      const senderLabel = message.sender.name || message.sender.id;
+      const titleParts = [platformTag, senderLabel];
       if (message.subject) titleParts.push(message.subject);
-      const title = titleParts.join(" \u2014 ") || `${message.platform} thread`;
+      const title = titleParts.join(" ") || `${message.platform} thread`;
       const conversation = await this.runner.getOrCreateConversation(
         conversationId,
         {
@@ -319,7 +332,7 @@ var SlackAdapter = class {
 import { createHmac as createHmac2 } from "crypto";
 
 // src/adapters/email/utils.ts
-import { createHash } from "crypto";
+import { createHash as createHash2 } from "crypto";
 var ADDR_RE = /<([^>]+)>/;
 function extractEmailAddress(formatted) {
   const match = ADDR_RE.exec(formatted);
@@ -350,7 +363,7 @@ function deriveRootMessageId(references, currentMessageId, fallback) {
   if (references.length > 0) return references[0];
   if (fallback) {
     const normalised = normaliseSubject(fallback.subject) + "\0" + fallback.sender.toLowerCase();
-    const hash = createHash("sha256").update(normalised).digest("hex").slice(0, 16);
+    const hash = createHash2("sha256").update(normalised).digest("hex").slice(0, 16);
     return `<fallback:${hash}>`;
   }
   return currentMessageId;
@@ -907,10 +920,445 @@ var ResendAdapter = class {
     return results;
   }
 };
+
+// src/adapters/telegram/verify.ts
+import { timingSafeEqual as timingSafeEqual2 } from "crypto";
+var verifyTelegramSecret = (expected, received) => {
+  if (!received) return false;
+  if (expected.length !== received.length) return false;
+  return timingSafeEqual2(Buffer.from(expected), Buffer.from(received));
+};
+
+// src/adapters/telegram/utils.ts
+var TELEGRAM_API = "https://api.telegram.org";
+var TELEGRAM_MAX_MESSAGE_LENGTH = 4096;
+var telegramFetch = async (token, method, body) => {
+  const res = await fetch(`${TELEGRAM_API}/bot${token}/${method}`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(body)
+  });
+  return await res.json();
+};
+var telegramUpload = async (token, method, formData) => {
+  const res = await fetch(`${TELEGRAM_API}/bot${token}/${method}`, {
+    method: "POST",
+    body: formData
+  });
+  return await res.json();
+};
+var getMe = async (token) => {
+  const result = await telegramFetch(token, "getMe", {});
+  if (!result.ok) {
+    throw new Error(`Telegram getMe failed: ${result.description}`);
+  }
+  const user = result.result;
+  return { id: user.id, username: user.username ?? "" };
+};
+var getFile = async (token, fileId) => {
+  const result = await telegramFetch(token, "getFile", { file_id: fileId });
+  if (!result.ok) {
+    throw new Error(`Telegram getFile failed: ${result.description}`);
+  }
+  const file = result.result;
+  if (!file.file_path) {
+    throw new Error("Telegram getFile: no file_path returned");
+  }
+  return file.file_path;
+};
+var EXTENSION_MEDIA_TYPES = {
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  png: "image/png",
+  gif: "image/gif",
+  webp: "image/webp",
+  pdf: "application/pdf",
+  mp4: "video/mp4",
+  ogg: "audio/ogg",
+  mp3: "audio/mpeg"
+};
+var inferMediaType = (filePath, header) => {
+  if (header && header !== "application/octet-stream") return header;
+  const ext = filePath.split(".").pop()?.toLowerCase();
+  if (ext && EXTENSION_MEDIA_TYPES[ext]) return EXTENSION_MEDIA_TYPES[ext];
+  return header ?? "application/octet-stream";
+};
+var downloadFile = async (token, filePath) => {
+  const url = `${TELEGRAM_API}/file/bot${token}/${filePath}`;
+  const res = await fetch(url);
+  if (!res.ok) {
+    throw new Error(`Telegram file download failed: ${res.status}`);
+  }
+  const buffer = Buffer.from(await res.arrayBuffer());
+  const mediaType = inferMediaType(filePath, res.headers.get("content-type"));
+  return { data: buffer.toString("base64"), mediaType };
+};
+var sendMessage = async (token, chatId, text, opts) => {
+  const body = { chat_id: chatId, text };
+  if (opts?.reply_to_message_id) {
+    body.reply_parameters = {
+      message_id: opts.reply_to_message_id,
+      allow_sending_without_reply: true
+    };
+  }
+  if (opts?.message_thread_id) {
+    body.message_thread_id = opts.message_thread_id;
+  }
+  const result = await telegramFetch(token, "sendMessage", body);
+  if (!result.ok) {
+    throw new Error(`Telegram sendMessage failed: ${result.description}`);
+  }
+};
+var sendPhoto = async (token, chatId, photoData, opts) => {
+  const formData = new FormData();
+  formData.append("chat_id", String(chatId));
+  const blob = new Blob([Buffer.from(photoData, "base64")]);
+  formData.append("photo", blob, opts?.filename ?? "photo.jpg");
+  if (opts?.caption) formData.append("caption", opts.caption);
+  if (opts?.reply_to_message_id) {
+    formData.append(
+      "reply_parameters",
+      JSON.stringify({
+        message_id: opts.reply_to_message_id,
+        allow_sending_without_reply: true
+      })
+    );
+  }
+  if (opts?.message_thread_id) {
+    formData.append("message_thread_id", String(opts.message_thread_id));
+  }
+  const result = await telegramUpload(token, "sendPhoto", formData);
+  if (!result.ok) {
+    throw new Error(`Telegram sendPhoto failed: ${result.description}`);
+  }
+};
+var sendDocument = async (token, chatId, docData, opts) => {
+  const formData = new FormData();
+  formData.append("chat_id", String(chatId));
+  const blob = new Blob([Buffer.from(docData, "base64")], {
+    type: opts?.mediaType
+  });
+  formData.append("document", blob, opts?.filename ?? "file");
+  if (opts?.caption) formData.append("caption", opts.caption);
+  if (opts?.reply_to_message_id) {
+    formData.append(
+      "reply_parameters",
+      JSON.stringify({
+        message_id: opts.reply_to_message_id,
+        allow_sending_without_reply: true
+      })
+    );
+  }
+  if (opts?.message_thread_id) {
+    formData.append("message_thread_id", String(opts.message_thread_id));
+  }
+  const result = await telegramUpload(token, "sendDocument", formData);
+  if (!result.ok) {
+    throw new Error(`Telegram sendDocument failed: ${result.description}`);
+  }
+};
+var sendChatAction = async (token, chatId, action) => {
+  await telegramFetch(token, "sendChatAction", {
+    chat_id: chatId,
+    action
+  });
+};
+var splitMessage2 = (text) => {
+  if (text.length <= TELEGRAM_MAX_MESSAGE_LENGTH) return [text];
+  const chunks = [];
+  let remaining = text;
+  while (remaining.length > 0) {
+    if (remaining.length <= TELEGRAM_MAX_MESSAGE_LENGTH) {
+      chunks.push(remaining);
+      break;
+    }
+    let cutPoint = remaining.lastIndexOf(
+      "\n",
+      TELEGRAM_MAX_MESSAGE_LENGTH
+    );
+    if (cutPoint <= 0) {
+      cutPoint = TELEGRAM_MAX_MESSAGE_LENGTH;
+    }
+    chunks.push(remaining.slice(0, cutPoint));
+    remaining = remaining.slice(cutPoint).replace(/^\n/, "");
+  }
+  return chunks;
+};
+var isBotMentioned = (entities, botUsername, botId, text) => {
+  if (!entities || entities.length === 0) return false;
+  const lower = botUsername.toLowerCase();
+  for (const entity of entities) {
+    if (entity.type === "mention") {
+      const mentioned = text.slice(entity.offset, entity.offset + entity.length);
+      if (mentioned.toLowerCase() === `@${lower}`) return true;
+    }
+    if (entity.type === "text_mention" && entity.user?.id === botId) {
+      return true;
+    }
+  }
+  return false;
+};
+var stripMention2 = (text, entities, botUsername, botId) => {
+  if (!entities || entities.length === 0) return text.trim();
+  const lower = botUsername.toLowerCase();
+  for (const entity of entities) {
+    let match = false;
+    if (entity.type === "mention") {
+      const mentioned = text.slice(entity.offset, entity.offset + entity.length);
+      if (mentioned.toLowerCase() === `@${lower}`) match = true;
+    }
+    if (entity.type === "text_mention" && entity.user?.id === botId) {
+      match = true;
+    }
+    if (match) {
+      return (text.slice(0, entity.offset) + text.slice(entity.offset + entity.length)).trim();
+    }
+  }
+  return text.trim();
+};
+
+// src/adapters/telegram/index.ts
+var TYPING_INTERVAL_MS = 4e3;
+var NEW_COMMAND_RE = /^\/new(?:@(\S+))?$/i;
+var collectBody3 = (req) => new Promise((resolve, reject) => {
+  const chunks = [];
+  req.on("data", (chunk) => chunks.push(chunk));
+  req.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+  req.on("error", reject);
+});
+var TelegramAdapter = class {
+  platform = "telegram";
+  autoReply = true;
+  hasSentInCurrentRequest = false;
+  botToken = "";
+  webhookSecret = "";
+  botUsername = "";
+  botId = 0;
+  botTokenEnv;
+  webhookSecretEnv;
+  handler;
+  sessionCounters = /* @__PURE__ */ new Map();
+  lastUpdateId = 0;
+  constructor(options = {}) {
+    this.botTokenEnv = options.botTokenEnv ?? "TELEGRAM_BOT_TOKEN";
+    this.webhookSecretEnv = options.webhookSecretEnv ?? "TELEGRAM_WEBHOOK_SECRET";
+  }
+  // -----------------------------------------------------------------------
+  // MessagingAdapter implementation
+  // -----------------------------------------------------------------------
+  async initialize() {
+    this.botToken = process.env[this.botTokenEnv] ?? "";
+    this.webhookSecret = process.env[this.webhookSecretEnv] ?? "";
+    if (!this.botToken) {
+      throw new Error(
+        `Telegram messaging: ${this.botTokenEnv} environment variable is not set`
+      );
+    }
+    const me = await getMe(this.botToken);
+    this.botUsername = me.username;
+    this.botId = me.id;
+  }
+  onMessage(handler) {
+    this.handler = handler;
+  }
+  registerRoutes(router) {
+    router(
+      "POST",
+      "/api/messaging/telegram",
+      (req, res) => this.handleRequest(req, res)
+    );
+  }
+  async sendReply(threadRef, content, options) {
+    const chatId = threadRef.channelId;
+    const replyTo = threadRef.messageId ? Number(threadRef.messageId) : void 0;
+    if (content) {
+      const chunks = splitMessage2(content);
+      for (const chunk of chunks) {
+        await sendMessage(this.botToken, chatId, chunk, {
+          reply_to_message_id: replyTo
+        });
+      }
+    }
+    if (options?.files) {
+      for (const file of options.files) {
+        if (file.mediaType.startsWith("image/")) {
+          await sendPhoto(this.botToken, chatId, file.data, {
+            reply_to_message_id: replyTo,
+            filename: file.filename
+          });
+        } else {
+          await sendDocument(this.botToken, chatId, file.data, {
+            reply_to_message_id: replyTo,
+            filename: file.filename,
+            mediaType: file.mediaType
+          });
+        }
+      }
+    }
+  }
+  async indicateProcessing(threadRef) {
+    const chatId = threadRef.channelId;
+    await sendChatAction(this.botToken, chatId, "typing");
+    const interval = setInterval(() => {
+      void sendChatAction(this.botToken, chatId, "typing").catch(() => {
+      });
+    }, TYPING_INTERVAL_MS);
+    return async () => {
+      clearInterval(interval);
+    };
+  }
+  // -----------------------------------------------------------------------
+  // HTTP request handling
+  // -----------------------------------------------------------------------
+  async handleRequest(req, res) {
+    const rawBody = await collectBody3(req);
+    if (this.webhookSecret) {
+      const headerSecret = req.headers["x-telegram-bot-api-secret-token"];
+      if (!verifyTelegramSecret(this.webhookSecret, headerSecret)) {
+        res.writeHead(401);
+        res.end("Invalid secret");
+        return;
+      }
+    }
+    let payload;
+    try {
+      payload = JSON.parse(rawBody);
+    } catch {
+      res.writeHead(400);
+      res.end("Invalid JSON");
+      return;
+    }
+    if (payload.update_id <= this.lastUpdateId) {
+      res.writeHead(200);
+      res.end();
+      return;
+    }
+    this.lastUpdateId = payload.update_id;
+    const message = payload.message;
+    if (!message) {
+      res.writeHead(200);
+      res.end();
+      return;
+    }
+    const text = message.text ?? message.caption ?? "";
+    const hasFiles = !!(message.photo || message.document);
+    if (!text && !hasFiles) {
+      res.writeHead(200);
+      res.end();
+      return;
+    }
+    const chatId = String(message.chat.id);
+    const chatType = message.chat.type;
+    const isGroup = chatType === "group" || chatType === "supergroup";
+    const entities = message.entities ?? message.caption_entities;
+    const newMatch = text.match(NEW_COMMAND_RE);
+    if (newMatch) {
+      const suffix = newMatch[1];
+      if (isGroup && suffix && suffix.toLowerCase() !== this.botUsername.toLowerCase()) {
+        res.writeHead(200);
+        res.end();
+        return;
+      }
+      const key2 = this.sessionKey(message);
+      const current = this.sessionCounters.get(key2) ?? 0;
+      this.sessionCounters.set(key2, current + 1);
+      res.writeHead(200);
+      res.end();
+      await sendMessage(
+        this.botToken,
+        chatId,
+        "Conversation reset. Send a new message to start fresh.",
+        {
+          reply_to_message_id: message.message_id,
+          message_thread_id: message.message_thread_id
+        }
+      );
+      return;
+    }
+    if (isGroup) {
+      if (!isBotMentioned(entities, this.botUsername, this.botId, text)) {
+        res.writeHead(200);
+        res.end();
+        return;
+      }
+    }
+    const cleanText = isGroup ? stripMention2(text, entities, this.botUsername, this.botId) : text;
+    if (!cleanText && !hasFiles) {
+      res.writeHead(200);
+      res.end();
+      return;
+    }
+    res.writeHead(200);
+    res.end();
+    if (!this.handler) return;
+    const files = await this.extractFiles(message);
+    const key = this.sessionKey(message);
+    const session = this.sessionCounters.get(key) ?? 0;
+    const topicId = message.message_thread_id;
+    const platformThreadId = topicId ? `${chatId}:${topicId}:${session}` : `${chatId}:${session}`;
+    const userId = String(message.from?.id ?? "unknown");
+    const userName = [message.from?.first_name, message.from?.last_name].filter(Boolean).join(" ") || void 0;
+    const ponchoMessage = {
+      text: cleanText,
+      files: files.length > 0 ? files : void 0,
+      threadRef: {
+        platformThreadId,
+        channelId: chatId,
+        messageId: String(message.message_id)
+      },
+      sender: { id: userId, name: userName },
+      platform: "telegram",
+      raw: message
+    };
+    void this.handler(ponchoMessage).catch((err) => {
+      console.error(
+        "[telegram-adapter] unhandled message handler error",
+        err
+      );
+    });
+  }
+  // -----------------------------------------------------------------------
+  // Helpers
+  // -----------------------------------------------------------------------
+  sessionKey(message) {
+    const chatId = String(message.chat.id);
+    return message.message_thread_id ? `${chatId}:${message.message_thread_id}` : chatId;
+  }
+  async extractFiles(message) {
+    const files = [];
+    try {
+      if (message.photo && message.photo.length > 0) {
+        const largest = message.photo[message.photo.length - 1];
+        const filePath = await getFile(this.botToken, largest.file_id);
+        const { data } = await downloadFile(this.botToken, filePath);
+        files.push({ data, mediaType: "image/jpeg", filename: "photo.jpg" });
+      }
+      if (message.document) {
+        const filePath = await getFile(
+          this.botToken,
+          message.document.file_id
+        );
+        const downloaded = await downloadFile(this.botToken, filePath);
+        files.push({
+          data: downloaded.data,
+          mediaType: message.document.mime_type ?? downloaded.mediaType,
+          filename: message.document.file_name
+        });
+      }
+    } catch (err) {
+      console.warn(
+        "[telegram-adapter] failed to download file:",
+        err instanceof Error ? err.message : err
+      );
+    }
+    return files;
+  }
+};
 export {
   AgentBridge,
   ResendAdapter,
   SlackAdapter,
+  TelegramAdapter,
   buildReplyHeaders,
   buildReplySubject,
   deriveRootMessageId,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@poncho-ai/messaging",
-  "version": "0.2.8",
+  "version": "0.3.0",
   "description": "Messaging platform adapters for Poncho agents (Slack, Telegram, etc.)",
   "repository": {
     "type": "git",
@@ -20,7 +20,7 @@
     }
   },
   "dependencies": {
-    "@poncho-ai/sdk": "1.4.0"
+    "@poncho-ai/sdk": "1.4.1"
   },
   "peerDependencies": {
     "resend": ">=4.0.0"
@@ -40,6 +40,7 @@
     "agent",
     "messaging",
     "slack",
+    "telegram",
     "email",
     "resend"
   ],