@elizaos/plugin-telegram 2.0.0-alpha.1 → 2.0.0-alpha.3

package/dist/index.js

@@ -18,7 +18,7 @@ var __toESM = (mod, isNodeMode, target) => {
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
-// ../../../node_modules/telegraf/node_modules/debug/node_modules/ms/index.js
+// ../../../node_modules/ms/index.js
 var require_ms = __commonJS((exports, module) => {
   var s = 1000;
   var m = s * 60;
@@ -128,7 +128,7 @@ var require_ms = __commonJS((exports, module) => {
   }
 });
 
-// ../../../node_modules/telegraf/node_modules/debug/src/common.js
+// ../../../node_modules/debug/src/common.js
 var require_common = __commonJS((exports, module) => {
   function setup(env) {
     createDebug.debug = createDebug;
@@ -303,7 +303,7 @@ var require_common = __commonJS((exports, module) => {
   module.exports = setup;
 });
 
-// ../../../node_modules/telegraf/node_modules/debug/src/browser.js
+// ../../../node_modules/debug/src/browser.js
 var require_browser = __commonJS((exports, module) => {
   exports.formatArgs = formatArgs;
   exports.save = save;
@@ -479,21 +479,19 @@ var require_supports_color = __commonJS((exports, module) => {
   var tty = __require("tty");
   var hasFlag = require_has_flag();
   var { env } = process;
-  var flagForceColor;
+  var forceColor;
   if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
-    flagForceColor = 0;
+    forceColor = 0;
   } else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
-    flagForceColor = 1;
+    forceColor = 1;
   }
-  function envForceColor() {
-    if ("FORCE_COLOR" in env) {
-      if (env.FORCE_COLOR === "true") {
-        return 1;
-      }
-      if (env.FORCE_COLOR === "false") {
-        return 0;
-      }
-      return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
+  if ("FORCE_COLOR" in env) {
+    if (env.FORCE_COLOR === "true") {
+      forceColor = 1;
+    } else if (env.FORCE_COLOR === "false") {
+      forceColor = 0;
+    } else {
+      forceColor = env.FORCE_COLOR.length === 0 ? 1 : Math.min(parseInt(env.FORCE_COLOR, 10), 3);
     }
   }
   function translateLevel(level) {
@@ -507,22 +505,15 @@ var require_supports_color = __commonJS((exports, module) => {
       has16m: level >= 3
     };
   }
-  function supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
-    const noFlagForceColor = envForceColor();
-    if (noFlagForceColor !== undefined) {
-      flagForceColor = noFlagForceColor;
-    }
-    const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
+  function supportsColor(haveStream, streamIsTTY) {
     if (forceColor === 0) {
       return 0;
     }
-    if (sniffFlags) {
-      if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
-        return 3;
-      }
-      if (hasFlag("color=256")) {
-        return 2;
-      }
+    if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
+      return 3;
+    }
+    if (hasFlag("color=256")) {
+      return 2;
     }
     if (haveStream && !streamIsTTY && forceColor === undefined) {
       return 0;
@@ -539,7 +530,7 @@ var require_supports_color = __commonJS((exports, module) => {
       return 1;
     }
     if ("CI" in env) {
-      if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI", "GITHUB_ACTIONS", "BUILDKITE", "DRONE"].some((sign) => (sign in env)) || env.CI_NAME === "codeship") {
+      if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI", "GITHUB_ACTIONS", "BUILDKITE"].some((sign) => (sign in env)) || env.CI_NAME === "codeship") {
         return 1;
       }
       return min;
@@ -551,7 +542,7 @@ var require_supports_color = __commonJS((exports, module) => {
       return 3;
     }
     if ("TERM_PROGRAM" in env) {
-      const version = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+      const version = parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
       switch (env.TERM_PROGRAM) {
         case "iTerm.app":
           return version >= 3 ? 3 : 2;
@@ -570,21 +561,18 @@ var require_supports_color = __commonJS((exports, module) => {
     }
     return min;
   }
-  function getSupportLevel(stream, options = {}) {
-    const level = supportsColor(stream, {
-      streamIsTTY: stream && stream.isTTY,
-      ...options
-    });
+  function getSupportLevel(stream) {
+    const level = supportsColor(stream, stream && stream.isTTY);
     return translateLevel(level);
   }
   module.exports = {
     supportsColor: getSupportLevel,
-    stdout: getSupportLevel({ isTTY: tty.isatty(1) }),
-    stderr: getSupportLevel({ isTTY: tty.isatty(2) })
+    stdout: translateLevel(supportsColor(true, tty.isatty(1))),
+    stderr: translateLevel(supportsColor(true, tty.isatty(2)))
   };
 });
 
-// ../../../node_modules/telegraf/node_modules/debug/src/node.js
+// ../../../node_modules/debug/src/node.js
 var require_node = __commonJS((exports, module) => {
   var tty = __require("tty");
   var util = __require("util");
@@ -755,7 +743,7 @@ var require_node = __commonJS((exports, module) => {
   };
 });
 
-// ../../../node_modules/telegraf/node_modules/debug/src/index.js
+// ../../../node_modules/debug/src/index.js
 var require_src = __commonJS((exports, module) => {
   if (typeof process === "undefined" || process.type === "renderer" || false || process.__nwjs) {
     module.exports = require_browser();
@@ -2765,7 +2753,7 @@ var require_abort_controller = __commonJS((exports, module) => {
     });
   }
 
-  class AbortController {
+  class AbortController2 {
     constructor() {
       signals.set(this, createAbortSignal());
     }
@@ -2784,21 +2772,21 @@ var require_abort_controller = __commonJS((exports, module) => {
     }
     return signal;
   }
-  Object.defineProperties(AbortController.prototype, {
+  Object.defineProperties(AbortController2.prototype, {
     signal: { enumerable: true },
     abort: { enumerable: true }
   });
   if (typeof Symbol === "function" && typeof Symbol.toStringTag === "symbol") {
-    Object.defineProperty(AbortController.prototype, Symbol.toStringTag, {
+    Object.defineProperty(AbortController2.prototype, Symbol.toStringTag, {
       configurable: true,
       value: "AbortController"
     });
   }
-  exports.AbortController = AbortController;
+  exports.AbortController = AbortController2;
   exports.AbortSignal = AbortSignal;
-  exports.default = AbortController;
-  module.exports = AbortController;
-  module.exports.AbortController = module.exports["default"] = AbortController;
+  exports.default = AbortController2;
+  module.exports = AbortController2;
+  module.exports.AbortController = module.exports["default"] = AbortController2;
   module.exports.AbortSignal = AbortSignal;
 });
 
@@ -9150,12 +9138,12 @@ var require_lib3 = __commonJS((exports, module) => {
   AbortError.prototype.name = "AbortError";
   var URL$1 = Url.URL || whatwgUrl.URL;
   var PassThrough$1 = Stream.PassThrough;
-  var isDomainOrSubdomain = function isDomainOrSubdomain(destination, original) {
+  var isDomainOrSubdomain = function isDomainOrSubdomain2(destination, original) {
     const orig = new URL$1(original).hostname;
     const dest = new URL$1(destination).hostname;
     return orig === dest || orig[orig.length - dest.length - 1] === "." && orig.endsWith(dest);
   };
-  var isSameProtocol = function isSameProtocol(destination, original) {
+  var isSameProtocol = function isSameProtocol2(destination, original) {
     const orig = new URL$1(original).protocol;
     const dest = new URL$1(destination).protocol;
     return orig === dest;
@@ -9171,7 +9159,7 @@ var require_lib3 = __commonJS((exports, module) => {
       const send = (options.protocol === "https:" ? https : http).request;
       const signal = request.signal;
       let response = null;
-      const abort = function abort() {
+      const abort = function abort2() {
         let error = new AbortError("The user aborted a request.");
         reject(error);
         if (request.body && request.body instanceof Stream.Readable) {
@@ -9185,7 +9173,7 @@ var require_lib3 = __commonJS((exports, module) => {
         abort();
         return;
       }
-      const abortAndFinalize = function abortAndFinalize() {
+      const abortAndFinalize = function abortAndFinalize2() {
         abort();
         finalize();
       };
@@ -10866,7 +10854,7 @@ var require_buffer_alloc = __commonJS((exports, module) => {
 var require_safe_compare = __commonJS((exports, module) => {
   var crypto = __require("crypto");
   var bufferAlloc = require_buffer_alloc();
-  var safeCompare = function safeCompare(a, b) {
+  var safeCompare = function safeCompare2(a, b) {
     var strA = String(a);
     var strB = String(b);
     var lenA = strA.length;
@@ -10880,7 +10868,7 @@ var require_safe_compare = __commonJS((exports, module) => {
     }
     return result === 0;
   };
-  var nativeTimingSafeEqual = function nativeTimingSafeEqual(a, b) {
+  var nativeTimingSafeEqual = function nativeTimingSafeEqual2(a, b) {
     var strA = String(a);
     var strB = String(b);
     var aLen = Buffer.byteLength(strA);
@@ -12034,6 +12022,321 @@ var sendMessageAction = {
     ]
   ]
 };
+// src/actions/sendReaction.ts
+import { composePromptFromState, ModelType, parseJSONObjectFromText } from "@elizaos/core";
+
+// src/types.ts
+var TelegramEventTypes;
+((TelegramEventTypes2) => {
+  TelegramEventTypes2["WORLD_JOINED"] = "TELEGRAM_WORLD_JOINED";
+  TelegramEventTypes2["WORLD_CONNECTED"] = "TELEGRAM_WORLD_CONNECTED";
+  TelegramEventTypes2["WORLD_LEFT"] = "TELEGRAM_WORLD_LEFT";
+  TelegramEventTypes2["ENTITY_JOINED"] = "TELEGRAM_ENTITY_JOINED";
+  TelegramEventTypes2["ENTITY_LEFT"] = "TELEGRAM_ENTITY_LEFT";
+  TelegramEventTypes2["ENTITY_UPDATED"] = "TELEGRAM_ENTITY_UPDATED";
+  TelegramEventTypes2["MESSAGE_RECEIVED"] = "TELEGRAM_MESSAGE_RECEIVED";
+  TelegramEventTypes2["MESSAGE_SENT"] = "TELEGRAM_MESSAGE_SENT";
+  TelegramEventTypes2["REACTION_RECEIVED"] = "TELEGRAM_REACTION_RECEIVED";
+  TelegramEventTypes2["REACTION_SENT"] = "TELEGRAM_REACTION_SENT";
+  TelegramEventTypes2["INTERACTION_RECEIVED"] = "TELEGRAM_INTERACTION_RECEIVED";
+  TelegramEventTypes2["SLASH_START"] = "TELEGRAM_SLASH_START";
+  TelegramEventTypes2["BOT_STARTED"] = "TELEGRAM_BOT_STARTED";
+  TelegramEventTypes2["BOT_STOPPED"] = "TELEGRAM_BOT_STOPPED";
+  TelegramEventTypes2["WEBHOOK_REGISTERED"] = "TELEGRAM_WEBHOOK_REGISTERED";
+})(TelegramEventTypes ||= {});
+var TELEGRAM_REACTIONS = {
+  THUMBS_UP: "\uD83D\uDC4D",
+  THUMBS_DOWN: "\uD83D\uDC4E",
+  HEART: "❤",
+  FIRE: "\uD83D\uDD25",
+  CELEBRATION: "\uD83C\uDF89",
+  CRYING: "\uD83D\uDE22",
+  THINKING: "\uD83E\uDD14",
+  EXPLODING_HEAD: "\uD83E\uDD2F",
+  SCREAMING: "\uD83D\uDE31",
+  ANGRY: "\uD83E\uDD2C",
+  SKULL: "\uD83D\uDC80",
+  POOP: "\uD83D\uDCA9",
+  CLOWN: "\uD83E\uDD21",
+  QUESTION: "\uD83E\uDD28",
+  EYES: "\uD83D\uDC40",
+  WHALE: "\uD83D\uDC33",
+  HEART_ON_FIRE: "❤️‍\uD83D\uDD25",
+  NEW_MOON: "\uD83C\uDF1A",
+  HOT_DOG: "\uD83C\uDF2D",
+  HUNDRED: "\uD83D\uDCAF",
+  TEARS_OF_JOY: "\uD83D\uDE02",
+  LIGHTNING: "⚡",
+  BANANA: "\uD83C\uDF4C",
+  TROPHY: "\uD83C\uDFC6",
+  BROKEN_HEART: "\uD83D\uDC94",
+  FACE_WITH_RAISED_EYEBROW: "\uD83E\uDD28",
+  NEUTRAL: "\uD83D\uDE10",
+  STRAWBERRY: "\uD83C\uDF53",
+  CHAMPAGNE: "\uD83C\uDF7E",
+  KISS: "\uD83D\uDC8B",
+  MIDDLE_FINGER: "\uD83D\uDD95",
+  DEVIL: "\uD83D\uDE08",
+  SLEEPING: "\uD83D\uDE34",
+  LOUDLY_CRYING: "\uD83D\uDE2D",
+  NERD: "\uD83E\uDD13",
+  GHOST: "\uD83D\uDC7B",
+  TECHNOLOGIST: "\uD83D\uDC68‍\uD83D\uDCBB",
+  UNICORN: "\uD83E\uDD84"
+};
+
+// src/actions/sendReaction.ts
+var SEND_REACTION_ACTION = "SEND_TELEGRAM_REACTION";
+var REACTION_EXTRACTION_TEMPLATE = `
+You are extracting reaction parameters from a conversation.
+
+The user wants to react to a Telegram message. Extract the following:
+1. reaction: The emoji to use as a reaction (must be a valid Telegram reaction emoji)
+2. messageId: The message ID to react to (if specified, otherwise use the current message)
+3. isBig: Whether to use a big/animated reaction (default: false)
+
+Valid Telegram reaction emojis include:
+\uD83D\uDC4D \uD83D\uDC4E ❤ \uD83D\uDD25 \uD83C\uDF89 \uD83D\uDE22 \uD83E\uDD14 \uD83E\uDD2F \uD83D\uDE31 \uD83E\uDD2C \uD83D\uDC80 \uD83D\uDCA9 \uD83E\uDD21 \uD83E\uDD28 \uD83D\uDC40 \uD83D\uDC33 ❤️‍\uD83D\uDD25 \uD83C\uDF1A \uD83C\uDF2D \uD83D\uDCAF \uD83D\uDE02 ⚡ \uD83C\uDF4C \uD83C\uDFC6 \uD83D\uDC94 \uD83D\uDE10 \uD83C\uDF53 \uD83C\uDF7E \uD83D\uDC8B \uD83D\uDD95 \uD83D\uDE08 \uD83D\uDE34 \uD83D\uDE2D \uD83E\uDD13 \uD83D\uDC7B \uD83D\uDC68‍\uD83D\uDCBB \uD83E\uDD84
+
+{{recentMessages}}
+
+Based on the conversation, extract the reaction parameters.
+If the user mentions "thumbs up", "like", or similar, use \uD83D\uDC4D.
+If the user mentions "heart", "love", use ❤.
+If the user mentions "fire", "lit", use \uD83D\uDD25.
+If the user doesn't specify a message, react to their current message.
+
+Respond with a JSON object:
+{
+  "reaction": "emoji here",
+  "messageId": number or null,
+  "isBig": boolean
+}
+`;
+var sendReactionAction = {
+  name: SEND_REACTION_ACTION,
+  similes: [
+    "TELEGRAM_REACT",
+    "TELEGRAM_REACTION",
+    "REACT_TO_MESSAGE",
+    "ADD_REACTION",
+    "SEND_EMOJI",
+    "TELEGRAM_EMOJI"
+  ],
+  description: "Send a reaction emoji to a Telegram message",
+  validate: async (_runtime, message) => {
+    const source = message.content?.source;
+    return source === "telegram";
+  },
+  handler: async (runtime, message, state, _options, callback) => {
+    const telegramService = runtime.getService(TELEGRAM_SERVICE_NAME);
+    if (!telegramService) {
+      if (callback) {
+        await callback({
+          text: "Telegram service not available"
+        });
+      }
+      return { success: false, error: "Telegram service not initialized" };
+    }
+    const chatId = message.content?.chatId;
+    if (!chatId) {
+      if (callback) {
+        await callback({
+          text: "No chat ID available"
+        });
+      }
+      return { success: false, error: "Missing chat ID" };
+    }
+    const currentState = state ?? await runtime.composeState(message);
+    const prompt = composePromptFromState({
+      state: currentState,
+      template: REACTION_EXTRACTION_TEMPLATE
+    });
+    let params;
+    try {
+      const response = await runtime.useModel(ModelType.TEXT_SMALL, {
+        prompt
+      });
+      const parsed = parseJSONObjectFromText(response);
+      if (!parsed || !parsed.reaction) {
+        params = {
+          reaction: TELEGRAM_REACTIONS.THUMBS_UP,
+          isBig: false
+        };
+      } else {
+        params = parsed;
+      }
+    } catch {
+      params = {
+        reaction: TELEGRAM_REACTIONS.THUMBS_UP,
+        isBig: false
+      };
+    }
+    const targetMessageId = params.messageId ?? message.content?.messageId;
+    if (!targetMessageId) {
+      if (callback) {
+        await callback({
+          text: "No message ID available to react to"
+        });
+      }
+      return { success: false, error: "Missing message ID" };
+    }
+    const result = await telegramService.sendReaction({
+      chatId,
+      messageId: targetMessageId,
+      reaction: params.reaction,
+      isBig: params.isBig
+    });
+    if (result.success) {
+      if (callback) {
+        await callback({
+          text: `Reacted with ${params.reaction}`,
+          action: SEND_REACTION_ACTION
+        });
+      }
+      return {
+        success: true,
+        data: {
+          action: SEND_REACTION_ACTION,
+          chatId,
+          messageId: targetMessageId,
+          reaction: params.reaction
+        }
+      };
+    } else {
+      if (callback) {
+        await callback({
+          text: `Failed to send reaction: ${result.error}`
+        });
+      }
+      return { success: false, error: result.error };
+    }
+  },
+  examples: [
+    [
+      {
+        name: "{{name1}}",
+        content: {
+          text: "React to my message with a thumbs up"
+        }
+      },
+      {
+        name: "{{agentName}}",
+        content: {
+          text: "I'll add a thumbs up reaction to your message.",
+          actions: [SEND_REACTION_ACTION]
+        }
+      }
+    ],
+    [
+      {
+        name: "{{name1}}",
+        content: {
+          text: "Give that a heart reaction"
+        }
+      },
+      {
+        name: "{{agentName}}",
+        content: {
+          text: "Adding a heart reaction now.",
+          actions: [SEND_REACTION_ACTION]
+        }
+      }
+    ],
+    [
+      {
+        name: "{{name1}}",
+        content: {
+          text: "\uD83D\uDD25 that message"
+        }
+      },
+      {
+        name: "{{agentName}}",
+        content: {
+          text: "I'll react with the fire emoji.",
+          actions: [SEND_REACTION_ACTION]
+        }
+      }
+    ]
+  ]
+};
+// src/environment.ts
+import { z } from "zod";
+var telegramEnvSchema = z.object({
+  TELEGRAM_BOT_TOKEN: z.string().min(1, "Telegram bot token is required"),
+  TELEGRAM_API_ROOT: z.string().optional(),
+  TELEGRAM_UPDATE_MODE: z.enum(["polling", "webhook"]).optional().default("polling"),
+  TELEGRAM_WEBHOOK_URL: z.string().url().optional(),
+  TELEGRAM_WEBHOOK_PATH: z.string().optional(),
+  TELEGRAM_WEBHOOK_PORT: z.coerce.number().optional(),
+  TELEGRAM_WEBHOOK_SECRET: z.string().optional(),
+  TELEGRAM_ALLOWED_CHATS: z.string().optional(),
+  TELEGRAM_PROXY_URL: z.string().url().optional(),
+  TELEGRAM_DROP_PENDING_UPDATES: z.coerce.boolean().optional().default(true),
+  TELEGRAM_SHOULD_IGNORE_BOT_MESSAGES: z.coerce.boolean().optional().default(true),
+  TELEGRAM_SHOULD_RESPOND_ONLY_TO_MENTIONS: z.coerce.boolean().optional().default(false)
+});
+function parseAllowedChats(value) {
+  if (!value)
+    return [];
+  const trimmed = value.trim();
+  if (!trimmed)
+    return [];
+  if (trimmed.startsWith("[")) {
+    const parsed = JSON.parse(trimmed);
+    if (Array.isArray(parsed)) {
+      return parsed.map((id) => {
+        const num = typeof id === "string" ? parseInt(id, 10) : Number(id);
+        return Number.isFinite(num) ? num : 0;
+      }).filter((id) => id !== 0);
+    }
+  }
+  return trimmed.split(",").map((s) => parseInt(s.trim(), 10)).filter((id) => Number.isFinite(id));
+}
+async function validateTelegramConfig(runtime) {
+  try {
+    const config = {
+      TELEGRAM_BOT_TOKEN: runtime.getSetting("TELEGRAM_BOT_TOKEN") || process.env.TELEGRAM_BOT_TOKEN,
+      TELEGRAM_API_ROOT: runtime.getSetting("TELEGRAM_API_ROOT") || process.env.TELEGRAM_API_ROOT,
+      TELEGRAM_UPDATE_MODE: runtime.getSetting("TELEGRAM_UPDATE_MODE") || process.env.TELEGRAM_UPDATE_MODE,
+      TELEGRAM_WEBHOOK_URL: runtime.getSetting("TELEGRAM_WEBHOOK_URL") || process.env.TELEGRAM_WEBHOOK_URL,
+      TELEGRAM_WEBHOOK_PATH: runtime.getSetting("TELEGRAM_WEBHOOK_PATH") || process.env.TELEGRAM_WEBHOOK_PATH,
+      TELEGRAM_WEBHOOK_PORT: runtime.getSetting("TELEGRAM_WEBHOOK_PORT") || process.env.TELEGRAM_WEBHOOK_PORT,
+      TELEGRAM_WEBHOOK_SECRET: runtime.getSetting("TELEGRAM_WEBHOOK_SECRET") || process.env.TELEGRAM_WEBHOOK_SECRET,
+      TELEGRAM_ALLOWED_CHATS: runtime.getSetting("TELEGRAM_ALLOWED_CHATS") || process.env.TELEGRAM_ALLOWED_CHATS,
+      TELEGRAM_PROXY_URL: runtime.getSetting("TELEGRAM_PROXY_URL") || process.env.TELEGRAM_PROXY_URL,
+      TELEGRAM_DROP_PENDING_UPDATES: runtime.getSetting("TELEGRAM_DROP_PENDING_UPDATES") || process.env.TELEGRAM_DROP_PENDING_UPDATES,
+      TELEGRAM_SHOULD_IGNORE_BOT_MESSAGES: runtime.getSetting("TELEGRAM_SHOULD_IGNORE_BOT_MESSAGES") || process.env.TELEGRAM_SHOULD_IGNORE_BOT_MESSAGES,
+      TELEGRAM_SHOULD_RESPOND_ONLY_TO_MENTIONS: runtime.getSetting("TELEGRAM_SHOULD_RESPOND_ONLY_TO_MENTIONS") || process.env.TELEGRAM_SHOULD_RESPOND_ONLY_TO_MENTIONS
+    };
+    return telegramEnvSchema.parse(config);
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      const errorMessages = error.issues.map((err) => `${err.path.join(".")}: ${err.message}`).join(`
+`);
+      console.warn(`Telegram configuration validation failed:
+${errorMessages}`);
+    }
+    return null;
+  }
+}
+function buildTelegramSettings(config) {
+  return {
+    botToken: config.TELEGRAM_BOT_TOKEN,
+    apiRoot: config.TELEGRAM_API_ROOT || "https://api.telegram.org",
+    updateMode: config.TELEGRAM_UPDATE_MODE || "polling",
+    webhookUrl: config.TELEGRAM_WEBHOOK_URL,
+    webhookPath: config.TELEGRAM_WEBHOOK_PATH || "/telegram/webhook",
+    webhookPort: config.TELEGRAM_WEBHOOK_PORT,
+    webhookSecret: config.TELEGRAM_WEBHOOK_SECRET,
+    allowedChatIds: parseAllowedChats(config.TELEGRAM_ALLOWED_CHATS),
+    proxyUrl: config.TELEGRAM_PROXY_URL,
+    dropPendingUpdates: config.TELEGRAM_DROP_PENDING_UPDATES ?? true,
+    shouldIgnoreBotMessages: config.TELEGRAM_SHOULD_IGNORE_BOT_MESSAGES ?? true,
+    shouldRespondOnlyToMentions: config.TELEGRAM_SHOULD_RESPOND_ONLY_TO_MENTIONS ?? false
+  };
+}
+
 // src/messageManager.ts
 var import_telegraf2 = __toESM(require_lib4(), 1);
 import fs from "node:fs";
@@ -12043,7 +12346,7 @@ import {
   EventType,
   logger as logger2,
   MemoryType,
-  ModelType,
+  ModelType as ModelType2,
   ServiceType
 } from "@elizaos/core";
 
@@ -12212,7 +12515,7 @@ class MessageManager {
       imageUrl = fileLink.toString();
     }
     if (imageUrl) {
-      const { title, description } = await this.runtime.useModel(ModelType.IMAGE_DESCRIPTION, imageUrl);
+      const { title, description } = await this.runtime.useModel(ModelType2.IMAGE_DESCRIPTION, imageUrl);
       return { description: `[Image: ${title}
 ${description}]` };
     }
@@ -12810,12 +13113,134 @@ var chatStateProvider = {
 var import_telegraf3 = __toESM(require_lib4(), 1);
 import {
   ChannelType as ChannelType2,
+  checkPairingAllowed,
   createUniqueUuid as createUniqueUuid2,
   EventType as EventType2,
+  isInAllowlist,
   logger as logger3,
   Role,
   Service
 } from "@elizaos/core";
+
+// src/accounts.ts
+var DEFAULT_ACCOUNT_ID = "default";
+function normalizeAccountId(accountId) {
+  if (!accountId || typeof accountId !== "string") {
+    return DEFAULT_ACCOUNT_ID;
+  }
+  const trimmed = accountId.trim().toLowerCase();
+  return trimmed || DEFAULT_ACCOUNT_ID;
+}
+function normalizeTelegramToken(raw) {
+  const trimmed = raw?.trim();
+  return trimmed || undefined;
+}
+function getMultiAccountConfig(runtime) {
+  const characterTelegram = runtime.character?.settings?.telegram;
+  return {
+    enabled: characterTelegram?.enabled,
+    token: characterTelegram?.token,
+    accounts: characterTelegram?.accounts
+  };
+}
+function listTelegramAccountIds(runtime) {
+  const config = getMultiAccountConfig(runtime);
+  const accounts = config.accounts;
+  if (!accounts || typeof accounts !== "object") {
+    return [DEFAULT_ACCOUNT_ID];
+  }
+  const ids = Object.keys(accounts).filter(Boolean);
+  if (ids.length === 0) {
+    return [DEFAULT_ACCOUNT_ID];
+  }
+  return ids.slice().sort((a, b) => a.localeCompare(b));
+}
+function resolveDefaultTelegramAccountId(runtime) {
+  const ids = listTelegramAccountIds(runtime);
+  if (ids.includes(DEFAULT_ACCOUNT_ID)) {
+    return DEFAULT_ACCOUNT_ID;
+  }
+  return ids[0] ?? DEFAULT_ACCOUNT_ID;
+}
+function getAccountConfig(runtime, accountId) {
+  const config = getMultiAccountConfig(runtime);
+  const accounts = config.accounts;
+  if (!accounts || typeof accounts !== "object") {
+    return;
+  }
+  return accounts[accountId];
+}
+function mergeTelegramAccountConfig(runtime, accountId) {
+  const multiConfig = getMultiAccountConfig(runtime);
+  const { accounts: _ignored, ...baseConfig } = multiConfig;
+  const accountConfig = getAccountConfig(runtime, accountId) ?? {};
+  const envUpdateMode = runtime.getSetting("TELEGRAM_UPDATE_MODE");
+  const envWebhookUrl = runtime.getSetting("TELEGRAM_WEBHOOK_URL");
+  const envWebhookPort = runtime.getSetting("TELEGRAM_WEBHOOK_PORT");
+  const envWebhookPath = runtime.getSetting("TELEGRAM_WEBHOOK_PATH");
+  const envWebhookSecret = runtime.getSetting("TELEGRAM_WEBHOOK_SECRET");
+  const envApiRoot = runtime.getSetting("TELEGRAM_API_ROOT");
+  const envAllowedChats = runtime.getSetting("TELEGRAM_ALLOWED_CHATS");
+  const envConfig = {
+    updateMode: envUpdateMode === "webhook" ? "webhook" : "polling",
+    webhookUrl: envWebhookUrl || undefined,
+    webhookPort: envWebhookPort ? parseInt(envWebhookPort, 10) : undefined,
+    webhookPath: envWebhookPath || undefined,
+    webhookSecret: envWebhookSecret || undefined,
+    apiRoot: envApiRoot || undefined,
+    allowedChatIds: envAllowedChats ? envAllowedChats.split(",").map((s) => s.trim()).filter(Boolean) : undefined
+  };
+  return {
+    ...envConfig,
+    ...baseConfig,
+    ...accountConfig
+  };
+}
+function resolveTelegramToken(runtime, opts = {}) {
+  const accountId = normalizeAccountId(opts.accountId);
+  const multiConfig = getMultiAccountConfig(runtime);
+  const accountConfig = accountId !== DEFAULT_ACCOUNT_ID ? multiConfig.accounts?.[accountId] : multiConfig.accounts?.[DEFAULT_ACCOUNT_ID];
+  const accountToken = normalizeTelegramToken(accountConfig?.token);
+  if (accountToken) {
+    return { token: accountToken, source: "config" };
+  }
+  const allowBase = accountId === DEFAULT_ACCOUNT_ID;
+  const baseToken = allowBase ? normalizeTelegramToken(multiConfig.token) : undefined;
+  if (baseToken) {
+    return { token: baseToken, source: "character" };
+  }
+  const envToken = allowBase ? normalizeTelegramToken(runtime.getSetting("TELEGRAM_BOT_TOKEN")) : undefined;
+  if (envToken) {
+    return { token: envToken, source: "env" };
+  }
+  return { token: "", source: "none" };
+}
+function resolveTelegramAccount(runtime, accountId) {
+  const normalizedAccountId = normalizeAccountId(accountId);
+  const multiConfig = getMultiAccountConfig(runtime);
+  const baseEnabled = multiConfig.enabled !== false;
+  const merged = mergeTelegramAccountConfig(runtime, normalizedAccountId);
+  const accountEnabled = merged.enabled !== false;
+  const enabled = baseEnabled && accountEnabled;
+  const tokenResolution = resolveTelegramToken(runtime, { accountId: normalizedAccountId });
+  return {
+    accountId: normalizedAccountId,
+    enabled,
+    name: merged.name?.trim() || undefined,
+    token: tokenResolution.token,
+    tokenSource: tokenResolution.source,
+    config: merged
+  };
+}
+function listEnabledTelegramAccounts(runtime) {
+  return listTelegramAccountIds(runtime).map((accountId) => resolveTelegramAccount(runtime, accountId)).filter((account) => account.enabled && account.token);
+}
+function isMultiAccountEnabled(runtime) {
+  const accounts = listEnabledTelegramAccounts(runtime);
+  return accounts.length > 1;
+}
+
+// src/service.ts
 class TelegramService extends Service {
   static serviceType = TELEGRAM_SERVICE_NAME;
   capabilityDescription = "The agent is able to send and receive messages on telegram";
@@ -12824,6 +13249,9 @@ class TelegramService extends Service {
   options;
   knownChats = new Map;
   syncedEntityIds = new Set;
+  settings = null;
+  botInfo = null;
+  webhookServer = null;
   constructor(runtime) {
     super(runtime);
     const botToken = runtime.getSetting("TELEGRAM_BOT_TOKEN");
@@ -12841,22 +13269,159 @@ class TelegramService extends Service {
     this.bot = new import_telegraf3.Telegraf(botToken, this.options);
     this.messageManager = new MessageManager(this.bot, this.runtime);
   }
+  getBotInfo() {
+    return this.botInfo;
+  }
+  getSettings() {
+    return this.settings;
+  }
+  async probeTelegram(timeoutMs = 5000) {
+    if (!this.bot) {
+      return {
+        ok: false,
+        error: "Bot not initialized",
+        latencyMs: 0
+      };
+    }
+    const startTime = Date.now();
+    const controller = new AbortController;
+    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+      const me = await this.bot.telegram.getMe();
+      const latencyMs = Date.now() - startTime;
+      return {
+        ok: true,
+        bot: {
+          id: me.id,
+          username: me.username,
+          firstName: me.first_name,
+          canJoinGroups: me.can_join_groups ?? false,
+          canReadAllGroupMessages: me.can_read_all_group_messages ?? false,
+          supportsInlineQueries: me.supports_inline_queries ?? false
+        },
+        latencyMs
+      };
+    } catch (error) {
+      const latencyMs = Date.now() - startTime;
+      return {
+        ok: false,
+        error: error instanceof Error ? error.message : String(error),
+        latencyMs
+      };
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  async sendReaction(params) {
+    if (!this.bot) {
+      return {
+        success: false,
+        chatId: params.chatId,
+        messageId: params.messageId,
+        reaction: params.reaction,
+        error: "Bot not initialized"
+      };
+    }
+    try {
+      const chatId = typeof params.chatId === "string" ? parseInt(params.chatId, 10) : params.chatId;
+      const reactionType = {
+        type: "emoji",
+        emoji: params.reaction
+      };
+      await this.bot.telegram.setMessageReaction(chatId, params.messageId, [reactionType], params.isBig ?? false);
+      this.runtime.emitEvent("TELEGRAM_REACTION_SENT" /* REACTION_SENT */, {
+        runtime: this.runtime,
+        chatId: params.chatId,
+        messageId: params.messageId,
+        reaction: params.reaction,
+        success: true
+      });
+      return {
+        success: true,
+        chatId: params.chatId,
+        messageId: params.messageId,
+        reaction: params.reaction
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      logger3.error({ error }, `Failed to send reaction: ${errorMessage}`);
+      return {
+        success: false,
+        chatId: params.chatId,
+        messageId: params.messageId,
+        reaction: params.reaction,
+        error: errorMessage
+      };
+    }
+  }
+  async removeReaction(chatId, messageId) {
+    if (!this.bot) {
+      return {
+        success: false,
+        chatId,
+        messageId,
+        reaction: "",
+        error: "Bot not initialized"
+      };
+    }
+    try {
+      const numericChatId = typeof chatId === "string" ? parseInt(chatId, 10) : chatId;
+      await this.bot.telegram.setMessageReaction(numericChatId, messageId, []);
+      return {
+        success: true,
+        chatId,
+        messageId,
+        reaction: ""
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      logger3.error({ error }, `Failed to remove reaction: ${errorMessage}`);
+      return {
+        success: false,
+        chatId,
+        messageId,
+        reaction: "",
+        error: errorMessage
+      };
+    }
+  }
   static async start(runtime) {
     const service = new TelegramService(runtime);
     if (!service.bot) {
       logger3.warn("Telegram service started without bot functionality - no bot token provided");
       return service;
     }
+    const config = await validateTelegramConfig(runtime);
+    if (config) {
+      service.settings = buildTelegramSettings(config);
+    }
     const maxRetries = 5;
     let retryCount = 0;
     let lastError = null;
     while (retryCount < maxRetries) {
       try {
         logger3.success(`Telegram client started for character ${runtime.character.name}`);
-        await service.initializeBot();
+        const botInfo = await service.bot?.telegram.getMe();
+        if (botInfo) {
+          service.botInfo = botInfo;
+          logger3.info(`Bot connected: @${botInfo.username} (ID: ${botInfo.id})`);
+        }
         service.setupMiddlewares();
         service.setupMessageHandlers();
-        await service.bot?.telegram.getMe();
+        const updateMode = service.settings?.updateMode || "polling";
+        if (updateMode === "webhook" && service.settings?.webhookUrl) {
+          await service.initializeWebhook();
+        } else {
+          await service.initializePolling();
+        }
+        service.runtime.emitEvent("TELEGRAM_BOT_STARTED" /* BOT_STARTED */, {
+          runtime: service.runtime,
+          botId: service.botInfo?.id,
+          botUsername: service.botInfo?.username,
+          botName: service.botInfo?.first_name,
+          updateMode,
+          timestamp: Date.now()
+        });
         return service;
       } catch (error) {
         lastError = error instanceof Error ? error : new Error(String(error));
@@ -12879,9 +13444,23 @@ class TelegramService extends Service {
     }
   }
   async stop() {
+    this.runtime.emitEvent("TELEGRAM_BOT_STOPPED" /* BOT_STOPPED */, {
+      runtime: this.runtime,
+      botId: this.botInfo?.id,
+      botUsername: this.botInfo?.username,
+      botName: this.botInfo?.first_name,
+      updateMode: this.settings?.updateMode || "polling",
+      timestamp: Date.now()
+    });
+    if (this.webhookServer) {
+      await new Promise((resolve) => {
+        this.webhookServer?.close(() => resolve());
+      });
+      this.webhookServer = null;
+    }
     this.bot?.stop();
   }
-  async initializeBot() {
+  async initializePolling() {
     this.bot?.start((ctx) => {
       this.runtime.emitEvent("TELEGRAM_SLASH_START" /* SLASH_START */, {
         runtime: this.runtime,
@@ -12889,17 +13468,102 @@ class TelegramService extends Service {
         ctx
       });
     });
+    const dropPendingUpdates = this.settings?.dropPendingUpdates ?? true;
     this.bot?.launch({
-      dropPendingUpdates: true,
-      allowedUpdates: ["message", "message_reaction"]
+      dropPendingUpdates,
+      allowedUpdates: ["message", "message_reaction", "chat_member", "my_chat_member"]
     });
-    const botInfo = await this.bot?.telegram.getMe();
-    logger3.log(`Bot info: ${JSON.stringify(botInfo)}`);
+    logger3.info(`Telegram bot started in polling mode (dropPendingUpdates: ${dropPendingUpdates})`);
     process.once("SIGINT", () => this.bot?.stop("SIGINT"));
     process.once("SIGTERM", () => this.bot?.stop("SIGTERM"));
   }
+  async initializeWebhook() {
+    if (!this.bot || !this.settings?.webhookUrl) {
+      throw new Error("Bot or webhook URL not configured");
+    }
+    const webhookUrl = this.settings.webhookUrl;
+    const webhookPath = this.settings.webhookPath || "/telegram/webhook";
+    const webhookPort = this.settings.webhookPort || 3000;
+    const webhookSecret = this.settings.webhookSecret;
+    this.bot.start((ctx) => {
+      this.runtime.emitEvent("TELEGRAM_SLASH_START" /* SLASH_START */, {
+        runtime: this.runtime,
+        source: "telegram",
+        ctx
+      });
+    });
+    const fullWebhookUrl = `${webhookUrl}${webhookPath}`;
+    await this.bot.telegram.setWebhook(fullWebhookUrl, {
+      secret_token: webhookSecret,
+      allowed_updates: ["message", "message_reaction", "chat_member", "my_chat_member"],
+      drop_pending_updates: this.settings.dropPendingUpdates
+    });
+    const webhookCallback = this.bot.webhookCallback(webhookPath, {
+      secretToken: webhookSecret
+    });
+    const http = await import("node:http");
+    this.webhookServer = http.createServer(async (req, res) => {
+      if (req.url === webhookPath && req.method === "POST") {
+        await webhookCallback(req, res);
+      } else if (req.url === "/health" || req.url === "/") {
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ status: "ok", bot: this.botInfo?.username }));
+      } else {
+        res.writeHead(404);
+        res.end("Not Found");
+      }
+    });
+    this.webhookServer.listen(webhookPort, () => {
+      logger3.info(`Telegram webhook server listening on port ${webhookPort}`);
+      logger3.info(`Webhook URL: ${fullWebhookUrl}`);
+    });
+    this.runtime.emitEvent("TELEGRAM_WEBHOOK_REGISTERED" /* WEBHOOK_REGISTERED */, {
+      runtime: this.runtime,
+      url: fullWebhookUrl,
+      path: webhookPath,
+      port: webhookPort,
+      hasSecret: !!webhookSecret,
+      timestamp: Date.now()
+    });
+    process.once("SIGINT", () => this.stop());
+    process.once("SIGTERM", () => this.stop());
+  }
+  async deleteWebhook() {
+    if (!this.bot) {
+      return false;
+    }
+    try {
+      await this.bot.telegram.deleteWebhook({ drop_pending_updates: true });
+      logger3.info("Webhook deleted successfully");
+      return true;
+    } catch (error) {
+      logger3.error({ error }, "Failed to delete webhook");
+      return false;
+    }
+  }
+  async getWebhookInfo() {
+    if (!this.bot) {
+      return null;
+    }
+    try {
+      const info = await this.bot.telegram.getWebhookInfo();
+      return {
+        url: info.url,
+        hasCustomCertificate: info.has_custom_certificate,
+        pendingUpdateCount: info.pending_update_count,
+        lastErrorDate: info.last_error_date,
+        lastErrorMessage: info.last_error_message,
+        maxConnections: info.max_connections,
+        allowedUpdates: info.allowed_updates
+      };
+    } catch (error) {
+      logger3.error({ error }, "Failed to get webhook info");
+      return null;
+    }
+  }
   setupMiddlewares() {
     this.bot?.use(this.authorizationMiddleware.bind(this));
+    this.bot?.use(this.dmAccessMiddleware.bind(this));
     this.bot?.use(this.chatAndEntityMiddleware.bind(this));
   }
   async authorizationMiddleware(ctx, next) {
@@ -12909,6 +13573,75 @@ class TelegramService extends Service {
     }
     await next();
   }
+  async dmAccessMiddleware(ctx, next) {
+    if (ctx.chat?.type !== "private") {
+      return next();
+    }
+    const accessResult = await this.checkDmAccess(ctx);
+    if (!accessResult.allowed) {
+      if (accessResult.replyMessage && ctx.from) {
+        try {
+          await this.bot?.telegram.sendMessage(ctx.from.id, accessResult.replyMessage);
+        } catch (err) {
+          logger3.warn({ error: err instanceof Error ? err.message : String(err), userId: ctx.from.id }, "Failed to send pairing reply");
+        }
+      }
+      return;
+    }
+    await next();
+  }
+  async checkDmAccess(ctx) {
+    if (!ctx.from) {
+      return { allowed: false };
+    }
+    const account = resolveTelegramAccount(this.runtime);
+    const dmConfig = account.config.dm;
+    const policy = dmConfig?.policy ?? "open";
+    const userId = ctx.from.id.toString();
+    if (policy === "disabled" || dmConfig?.enabled === false) {
+      logger3.debug({ userId }, "DM blocked: policy is disabled");
+      return { allowed: false };
+    }
+    if (policy === "open") {
+      return { allowed: true };
+    }
+    if (policy === "allowlist") {
+      const allowFrom = dmConfig?.allowFrom ?? [];
+      if (allowFrom.some((a) => String(a) === userId || String(a) === ctx.from?.username)) {
+        return { allowed: true };
+      }
+      const inDynamicAllowlist = await isInAllowlist(this.runtime, "telegram", userId);
+      if (inDynamicAllowlist) {
+        return { allowed: true };
+      }
+      logger3.debug({ userId }, "DM blocked: user not in allowlist");
+      return { allowed: false };
+    }
+    if (policy === "pairing") {
+      const allowFrom = dmConfig?.allowFrom ?? [];
+      if (allowFrom.some((a) => String(a) === userId || String(a) === ctx.from?.username)) {
+        return { allowed: true };
+      }
+      const result = await checkPairingAllowed(this.runtime, {
+        channel: "telegram",
+        senderId: userId,
+        metadata: {
+          username: ctx.from.username ?? "",
+          firstName: ctx.from.first_name ?? "",
+          lastName: ctx.from.last_name ?? ""
+        }
+      });
+      if (result.allowed) {
+        return { allowed: true };
+      }
+      logger3.debug({ userId, pairingCode: result.pairingCode, newRequest: result.newRequest }, "DM blocked: pairing required");
+      return {
+        allowed: false,
+        replyMessage: result.newRequest ? result.replyMessage : undefined
+      };
+    }
+    return { allowed: true };
+  }
   async chatAndEntityMiddleware(ctx, next) {
     if (!ctx.chat)
       return next();
@@ -13515,25 +14248,306 @@ class TelegramTestSuite {
     }
   }
 }
+// src/formatting.ts
+function escapeHtml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function escapeHtmlAttr(text) {
+  return escapeHtml(text).replace(/"/g, "&quot;");
+}
+function escapeMarkdownV2(text) {
+  return text.replace(/([_*[\]()~`>#+\-=|{}.!\\])/g, "\\$1");
+}
+function convertBold(text) {
+  return text.replace(/\*\*(.+?)\*\*/g, "<b>$1</b>");
+}
+function convertItalic(text) {
+  return text.replace(/(?<!\*)\*(?!\*)(.+?)(?<!\*)\*(?!\*)/g, "<i>$1</i>");
+}
+function convertUnderline(text) {
+  return text.replace(/__(.+?)__/g, "<u>$1</u>");
+}
+function convertStrikethrough(text) {
+  return text.replace(/~~(.+?)~~/g, "<s>$1</s>");
+}
+function convertInlineCode(text) {
+  return text.replace(/`([^`\n]+)`/g, (_, code) => `<code>${escapeHtml(code)}</code>`);
+}
+function convertCodeBlocks(text) {
+  return text.replace(/```(\w*)\n?([\s\S]*?)```/g, (_, lang, code) => {
+    const escapedCode = escapeHtml(code.trim());
+    if (lang) {
+      return `<pre><code class="language-${escapeHtmlAttr(lang)}">${escapedCode}</code></pre>`;
+    }
+    return `<pre><code>${escapedCode}</code></pre>`;
+  });
+}
+function convertLinks(text) {
+  return text.replace(/\[([^\]]+)\]\(([^)]+)\)/g, (_, linkText, url) => {
+    const safeUrl = escapeHtmlAttr(url.trim());
+    return `<a href="${safeUrl}">${escapeHtml(linkText)}</a>`;
+  });
+}
+function linkifyUrls(text) {
+  const urlRegex = /(?<!["'])(https?:\/\/[^\s<>"']+)/g;
+  return text.replace(urlRegex, (url) => {
+    const safeUrl = escapeHtmlAttr(url);
+    return `<a href="${safeUrl}">${escapeHtml(url)}</a>`;
+  });
+}
+function markdownToTelegramHtml(markdown, options = {}) {
+  if (!markdown) {
+    return "";
+  }
+  let result = markdown;
+  result = convertCodeBlocks(result);
+  result = convertInlineCode(result);
+  result = convertLinks(result);
+  const htmlTagPattern = /(<(?:b|i|u|s|code|pre|a)[^>]*>[\s\S]*?<\/(?:b|i|u|s|code|pre|a)>)/g;
+  const parts = result.split(htmlTagPattern);
+  result = parts.map((part, index) => {
+    if (index % 2 === 0) {
+      let text = escapeHtml(part);
+      text = convertBold(text);
+      text = convertItalic(text);
+      text = convertUnderline(text);
+      text = convertStrikethrough(text);
+      if (options.linkify !== false) {
+        text = linkifyUrls(text);
+      }
+      return text;
+    }
+    return part;
+  }).join("");
+  return result;
+}
+function markdownToTelegramChunks(markdown, limit, options = {}) {
+  const html = markdownToTelegramHtml(markdown, options);
+  const chunks = chunkTelegramText(html, limit);
+  return chunks.map((chunk) => ({
+    html: chunk,
+    text: stripHtmlTags(chunk)
+  }));
+}
+function markdownToTelegramHtmlChunks(markdown, limit) {
+  return markdownToTelegramChunks(markdown, limit).map((chunk) => chunk.html);
+}
+function stripHtmlTags(html) {
+  return html.replace(/<[^>]+>/g, "").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"');
+}
+var DEFAULT_MAX_CHARS = 4096;
+function chunkTelegramText(text, maxChars = DEFAULT_MAX_CHARS) {
+  if (!text) {
+    return [];
+  }
+  if (text.length <= maxChars) {
+    return [text];
+  }
+  const chunks = [];
+  let remaining = text;
+  while (remaining.length > 0) {
+    if (remaining.length <= maxChars) {
+      chunks.push(remaining);
+      break;
+    }
+    let breakPoint = maxChars;
+    const newlineIndex = remaining.lastIndexOf(`
+`, maxChars);
+    if (newlineIndex > maxChars * 0.5) {
+      breakPoint = newlineIndex + 1;
+    } else {
+      const spaceIndex = remaining.lastIndexOf(" ", maxChars);
+      if (spaceIndex > maxChars * 0.5) {
+        breakPoint = spaceIndex + 1;
+      }
+    }
+    const chunk = remaining.slice(0, breakPoint);
+    const openTags = chunk.match(/<(\w+)[^>]*>/g) || [];
+    const closeTags = chunk.match(/<\/(\w+)>/g) || [];
+    const tagStack = [];
+    for (const tag of openTags) {
+      const tagName = tag.match(/<(\w+)/)?.[1];
+      if (tagName && !tag.endsWith("/>")) {
+        tagStack.push(tagName);
+      }
+    }
+    for (const tag of closeTags) {
+      const tagName = tag.match(/<\/(\w+)>/)?.[1];
+      if (tagName) {
+        const index = tagStack.lastIndexOf(tagName);
+        if (index !== -1) {
+          tagStack.splice(index, 1);
+        }
+      }
+    }
+    let chunkWithClosedTags = chunk;
+    const closingTags = tagStack.slice().reverse().map((tag) => `</${tag}>`).join("");
+    chunkWithClosedTags += closingTags;
+    chunks.push(chunkWithClosedTags);
+    const openingTags = tagStack.map((tag) => `<${tag}>`).join("");
+    remaining = openingTags + remaining.slice(breakPoint);
+  }
+  return chunks;
+}
+function formatTelegramUser(user) {
+  if (user.username) {
+    return `@${user.username}`;
+  }
+  if (user.last_name) {
+    return `${user.first_name} ${user.last_name}`;
+  }
+  return user.first_name;
+}
+function formatTelegramUserMention(user) {
+  const displayName = formatTelegramUser(user);
+  return `<a href="tg://user?id=${user.id}">${escapeHtml(displayName)}</a>`;
+}
+function formatTelegramChat(chat) {
+  if (chat.type === "private") {
+    const privateChat = chat;
+    if (privateChat.username) {
+      return `@${privateChat.username}`;
+    }
+    if (privateChat.last_name) {
+      return `${privateChat.first_name} ${privateChat.last_name}`;
+    }
+    return privateChat.first_name || `User ${chat.id}`;
+  }
+  const groupChat = chat;
+  if ("username" in groupChat && groupChat.username) {
+    return `@${groupChat.username}`;
+  }
+  return groupChat.title || `Chat ${chat.id}`;
+}
+function getChatTypeString(chat) {
+  switch (chat.type) {
+    case "private":
+      return "DM";
+    case "group":
+      return "Group";
+    case "supergroup":
+      return "Supergroup";
+    case "channel":
+      return "Channel";
+    default:
+      return "Unknown";
+  }
+}
+function resolveTelegramSystemLocation(chat) {
+  const chatType = getChatTypeString(chat);
+  const chatName = formatTelegramChat(chat);
+  return `${chatType}: ${chatName}`;
+}
+function isPrivateChat(chat) {
+  return chat.type === "private";
+}
+function isGroupChat(chat) {
+  return chat.type === "group" || chat.type === "supergroup";
+}
+function isChannelChat(chat) {
+  return chat.type === "channel";
+}
+function truncateText(text, maxLength, ellipsis = "…") {
+  if (text.length <= maxLength) {
+    return text;
+  }
+  return text.slice(0, maxLength - ellipsis.length) + ellipsis;
+}
+function buildTelegramDeepLink(botUsername, startParam) {
+  const base = `https://t.me/${botUsername}`;
+  if (startParam) {
+    return `${base}?start=${encodeURIComponent(startParam)}`;
+  }
+  return base;
+}
+function buildTelegramMessageLink(chatUsername, messageId) {
+  return `https://t.me/${chatUsername}/${messageId}`;
+}
+function parseTelegramMessageLink(url) {
+  const match = url.match(/^https?:\/\/t\.me\/([^/]+)\/(\d+)$/);
+  if (!match) {
+    return null;
+  }
+  return {
+    chatUsername: match[1],
+    messageId: parseInt(match[2], 10)
+  };
+}
+function formatMediaCaption(text, maxLength = 1024) {
+  if (!text) {
+    return "";
+  }
+  if (text.length <= maxLength) {
+    return text;
+  }
+  let breakPoint = maxLength - 1;
+  const newlineIndex = text.lastIndexOf(`
+`, maxLength);
+  if (newlineIndex > maxLength * 0.5) {
+    breakPoint = newlineIndex;
+  } else {
+    const spaceIndex = text.lastIndexOf(" ", maxLength);
+    if (spaceIndex > maxLength * 0.5) {
+      breakPoint = spaceIndex;
+    }
+  }
+  return `${text.slice(0, breakPoint)}…`;
+}
 
 // src/index.ts
 var telegramPlugin = {
   name: TELEGRAM_SERVICE_NAME,
-  description: "Telegram client plugin",
+  description: "Telegram client plugin with polling and webhook support",
   services: [TelegramService],
-  actions: [sendMessageAction],
+  actions: [sendMessageAction, sendReactionAction],
   providers: [chatStateProvider],
   tests: [new TelegramTestSuite]
 };
 var src_default = telegramPlugin;
 export {
+  validateTelegramConfig,
+  truncateText,
+  stripHtmlTags,
+  sendReactionAction,
   sendMessageAction,
+  resolveTelegramToken,
+  resolveTelegramSystemLocation,
+  resolveTelegramAccount,
+  resolveDefaultTelegramAccountId,
+  parseTelegramMessageLink,
+  normalizeTelegramToken,
+  normalizeAccountId,
+  markdownToTelegramHtmlChunks,
+  markdownToTelegramHtml,
+  markdownToTelegramChunks,
+  listTelegramAccountIds,
+  listEnabledTelegramAccounts,
+  isPrivateChat,
+  isMultiAccountEnabled,
+  isGroupChat,
+  isChannelChat,
+  getChatTypeString,
+  formatTelegramUserMention,
+  formatTelegramUser,
+  formatTelegramChat,
+  formatMediaCaption,
+  escapeMarkdownV2,
+  escapeHtmlAttr,
+  escapeHtml,
   src_default as default,
+  chunkTelegramText,
   chatStateProvider,
+  buildTelegramSettings,
+  buildTelegramMessageLink,
+  buildTelegramDeepLink,
   TelegramService,
+  TelegramEventTypes,
+  TELEGRAM_REACTIONS,
+  SEND_REACTION_ACTION,
   SEND_MESSAGE_ACTION,
   MessageManager,
+  DEFAULT_ACCOUNT_ID,
   CHAT_STATE_PROVIDER
 };
 
-//# debugId=7D6DD157C30C505564756E2164756E21
+//# debugId=5EB5738096CCF54A64756E2164756E21