@elizaos/plugin-telegram 1.0.0-alpha.2 → 1.0.0-alpha.21

package/dist/index.js

@@ -1,10 +1,28 @@
 // src/index.ts
 import {
+  ChannelType as ChannelType2,
+  EventTypes as EventTypes2,
+  Role,
   Service,
+  createUniqueUuid as createUniqueUuid2,
   logger as logger3
 } from "@elizaos/core";
 import { Telegraf } from "telegraf";
 
+// src/constants.ts
+var MESSAGE_CONSTANTS = {
+  MAX_MESSAGES: 50,
+  RECENT_MESSAGE_COUNT: 5,
+  CHAT_HISTORY_COUNT: 10,
+  DEFAULT_SIMILARITY_THRESHOLD: 0.6,
+  DEFAULT_SIMILARITY_THRESHOLD_FOLLOW_UPS: 0.4,
+  INTEREST_DECAY_TIME: 5 * 60 * 1e3,
+  // 5 minutes
+  PARTIAL_INTEREST_DECAY: 3 * 60 * 1e3
+  // 3 minutes
+};
+var TELEGRAM_SERVICE_NAME = "telegram";
+
 // ../../node_modules/zod/lib/index.mjs
 var util;
 (function(util2) {
@@ -4074,10 +4092,10 @@ ${errorMessages}`
 // src/messageManager.ts
 import {
   ChannelType,
-  createUniqueUuid,
-  logger,
+  EventTypes,
   ModelTypes,
-  Role
+  createUniqueUuid,
+  logger
 } from "@elizaos/core";
 
 // src/utils.ts
@@ -4106,11 +4124,23 @@ var getChannelType = (chat) => {
 var MessageManager = class {
   bot;
   runtime;
+  /**
+   * Constructor for creating a new instance of a BotAgent.
+   *
+   * @param {Telegraf<Context>} bot - The Telegraf instance used for interacting with the bot platform.
+   * @param {IAgentRuntime} runtime - The runtime environment for the agent.
+   */
   constructor(bot, runtime) {
     this.bot = bot;
     this.runtime = runtime;
   }
   // Process image messages and generate descriptions
+  /**
+   * Process an image from a Telegram message to extract the image URL and description.
+   *
+   * @param {Message} message - The Telegram message object containing the image.
+   * @returns {Promise<{ description: string } | null>} The description of the processed image or null if no image found.
+   */
   async processImage(message) {
     var _a, _b, _c;
     try {
@@ -4140,6 +4170,14 @@ ${description}]` };
     return null;
   }
   // Send long messages in chunks
+  /**
+   * Sends a message in chunks, handling attachments and splitting the message if necessary
+   *
+   * @param {Context} ctx - The context object representing the current state of the bot
+   * @param {Content} content - The content of the message to be sent
+   * @param {number} [replyToMessageId] - The ID of the message to reply to, if any
+   * @returns {Promise<Message.TextMessage[]>} - An array of TextMessage objects representing the messages sent
+   */
   async sendMessageInChunks(ctx, content, replyToMessageId) {
     if (content.attachments && content.attachments.length > 0) {
       content.attachments.map(async (attachment) => {
@@ -4187,6 +4225,16 @@ ${description}]` };
       return sentMessages;
     }
   }
+  /**
+   * Sends media to a chat using the Telegram API.
+   *
+   * @param {Context} ctx - The context object containing information about the current chat.
+   * @param {string} mediaPath - The path to the media to be sent, either a URL or a local file path.
+   * @param {MediaType} type - The type of media being sent (PHOTO, VIDEO, DOCUMENT, AUDIO, or ANIMATION).
+   * @param {string} [caption] - Optional caption for the media being sent.
+   *
+   * @returns {Promise<void>} A Promise that resolves when the media is successfully sent.
+   */
   async sendMedia(ctx, mediaPath, type, caption) {
     try {
       const isUrl = /^(http|https):\/\//.test(mediaPath);
@@ -4226,6 +4274,12 @@ ${description}]` };
     }
   }
   // Split message into smaller parts
+  /**
+   * Splits a given text into an array of strings based on the maximum message length.
+   *
+   * @param {string} text - The text to split into chunks.
+   * @returns {string[]} An array of strings with each element representing a chunk of the original text.
+   */
   splitMessage(text) {
     const chunks = [];
     let currentChunk = "";
@@ -4242,6 +4296,11 @@ ${description}]` };
     return chunks;
   }
   // Main handler for incoming messages
+  /**
+   * Handle incoming messages from Telegram and process them accordingly.
+   * @param {Context} ctx - The context object containing information about the message.
+   * @returns {Promise<void>}
+   */
   async handleMessage(ctx) {
     var _a, _b;
     if (!ctx.message || !ctx.from) return;
@@ -4267,28 +4326,11 @@ ${description}]` };
       }
       const fullText = imageInfo ? `${messageText} ${imageInfo.description}` : messageText;
       if (!fullText) return;
-      const memory = {
-        id: messageId,
-        entityId,
-        agentId: this.runtime.agentId,
-        roomId,
-        content: {
-          text: fullText,
-          source: "telegram",
-          channelType: getChannelType(message.chat),
-          // name: userName,
-          // userName: userName,
-          // Safely access reply_to_message with type guard
-          inReplyTo: "reply_to_message" in message && message.reply_to_message ? createUniqueUuid(
-            this.runtime,
-            message.reply_to_message.message_id.toString()
-          ) : void 0
-        },
-        createdAt: message.date * 1e3
-      };
       const chat = message.chat;
-      const worldName = chat.type === "supergroup" ? chat.title : chat.type === "channel" ? chat.title : "undefined";
+      const channelType = getChannelType(chat);
+      const worldName = chat.type === "supergroup" ? chat.title : chat.type === "channel" ? chat.title : chat.type === "private" ? `Chat with ${chat.first_name || "Unknown"}` : "Telegram";
       const roomName = chat.type === "private" ? chat.first_name : chat.type === "supergroup" ? chat.title : chat.type === "channel" ? chat.title : chat.type === "group" ? chat.title : "Unknown Group";
+      const worldId = createUniqueUuid(this.runtime, chat.id.toString());
       await this.runtime.ensureConnection({
         entityId,
         roomId,
@@ -4297,10 +4339,9 @@ ${description}]` };
         source: "telegram",
         channelId: ctx.chat.id.toString(),
         serverId: chat.id.toString(),
-        type: getChannelType(chat)
+        type: channelType,
+        worldId
       });
-      const channelType = getChannelType(chat);
-      const worldId = createUniqueUuid(this.runtime, chat.id.toString());
       const room = {
         id: roomId,
         name: roomName,
@@ -4310,24 +4351,23 @@ ${description}]` };
         serverId: ctx.chat.id.toString(),
         worldId
       };
-      const ownerId = chat.id;
-      if (channelType === ChannelType.GROUP) {
-        await this.runtime.ensureWorldExists({
-          id: worldId,
-          name: worldName,
-          serverId: chat.id.toString(),
-          agentId: this.runtime.agentId,
-          metadata: {
-            ownership: chat.type === "supergroup" ? { ownerId: chat.id.toString() } : void 0,
-            roles: {
-              // TODO: chat.id is probably wrong key for this
-              [ownerId]: Role.OWNER
-            }
-          }
-        });
-        room.worldId = worldId;
-      }
       await this.runtime.ensureRoomExists(room);
+      const memory = {
+        id: messageId,
+        entityId,
+        agentId: this.runtime.agentId,
+        roomId,
+        content: {
+          text: fullText,
+          source: "telegram",
+          channelType,
+          inReplyTo: "reply_to_message" in message && message.reply_to_message ? createUniqueUuid(
+            this.runtime,
+            message.reply_to_message.message_id.toString()
+          ) : void 0
+        },
+        createdAt: message.date * 1e3
+      };
       const callback = async (content, _files) => {
         try {
           const sentMessages = await this.sendMessageInChunks(
@@ -4352,7 +4392,7 @@ ${description}]` };
                 ...content,
                 text: sentMessage.text,
                 inReplyTo: messageId,
-                channelType: getChannelType(message.chat)
+                channelType
               },
               createdAt: sentMessage.date * 1e3
             };
@@ -4366,11 +4406,23 @@ ${description}]` };
         }
       };
       this.runtime.emitEvent(
-        ["TELEGRAM_MESSAGE_RECEIVED", "MESSAGE_RECEIVED"],
+        EventTypes.MESSAGE_RECEIVED,
+        {
+          runtime: this.runtime,
+          message: memory,
+          callback,
+          source: "telegram"
+        }
+      );
+      this.runtime.emitEvent(
+        "TELEGRAM_MESSAGE_RECEIVED" /* MESSAGE_RECEIVED */,
         {
           runtime: this.runtime,
           message: memory,
-          callback
+          callback,
+          source: "telegram",
+          ctx,
+          originalMessage: message
         }
       );
     } catch (error) {
@@ -4379,6 +4431,11 @@ ${description}]` };
       throw error;
     }
   }
+  /**
+   * Handles the reaction event triggered by a user reacting to a message.
+   * * @param {NarrowedContext<Context<Update>, Update.MessageReactionUpdate>} ctx The context of the message reaction update
+   * @returns {Promise<void>} A Promise that resolves when the reaction handling is complete
+   */
   async handleReaction(ctx) {
     if (!ctx.update.message_reaction || !ctx.from) return;
     const reaction = ctx.update.message_reaction;
@@ -4390,6 +4447,7 @@ ${description}]` };
         ctx.from.id.toString()
       );
       const roomId = createUniqueUuid(this.runtime, ctx.chat.id.toString());
+      const worldId = createUniqueUuid(this.runtime, ctx.chat.id.toString());
       const reactionId = createUniqueUuid(
         this.runtime,
         `${reaction.message_id}-${ctx.from.id}-${Date.now()}`
@@ -4403,8 +4461,6 @@ ${description}]` };
           channelType: getChannelType(reaction.chat),
           text: `Reacted with: ${reactionType === "emoji" ? reactionEmoji : reactionType}`,
           source: "telegram",
-          // name: ctx.from.first_name,
-          // userName: ctx.from.username,
           inReplyTo: createUniqueUuid(
             this.runtime,
             reaction.message_id.toString()
@@ -4412,7 +4468,6 @@ ${description}]` };
         },
         createdAt: Date.now()
       };
-      await this.runtime.getMemoryManager("messages").createMemory(memory);
       const callback = async (content) => {
         try {
           const sentMessage = await ctx.reply(content.text);
@@ -4437,17 +4492,94 @@ ${description}]` };
         }
       };
       this.runtime.emitEvent(
-        ["TELEGRAM_REACTION_RECEIVED", "REACTION_RECEIVED"],
+        EventTypes.REACTION_RECEIVED,
+        {
+          runtime: this.runtime,
+          message: memory,
+          callback,
+          source: "telegram"
+        }
+      );
+      this.runtime.emitEvent(
+        "TELEGRAM_REACTION_RECEIVED" /* REACTION_RECEIVED */,
         {
           runtime: this.runtime,
           message: memory,
-          callback
+          callback,
+          source: "telegram",
+          ctx,
+          reactionString: reactionType === "emoji" ? reactionEmoji : reactionType,
+          originalReaction: reaction.new_reaction[0]
         }
       );
     } catch (error) {
       logger.error("Error handling reaction:", error);
     }
   }
+  /**
+   * Sends a message to a Telegram chat and emits appropriate events
+   * @param {number | string} chatId - The Telegram chat ID to send the message to
+   * @param {Content} content - The content to send
+   * @param {number} [replyToMessageId] - Optional message ID to reply to
+   * @returns {Promise<Message.TextMessage[]>} The sent messages
+   */
+  async sendMessage(chatId, content, replyToMessageId) {
+    try {
+      const ctx = {
+        chat: { id: chatId },
+        telegram: this.bot.telegram
+      };
+      const sentMessages = await this.sendMessageInChunks(
+        ctx,
+        content,
+        replyToMessageId
+      );
+      if (!(sentMessages == null ? void 0 : sentMessages.length)) return [];
+      const roomId = createUniqueUuid(this.runtime, chatId.toString());
+      const memories = [];
+      for (const sentMessage of sentMessages) {
+        const memory = {
+          id: createUniqueUuid(this.runtime, sentMessage.message_id.toString()),
+          entityId: this.runtime.agentId,
+          agentId: this.runtime.agentId,
+          roomId,
+          content: {
+            ...content,
+            text: sentMessage.text,
+            source: "telegram",
+            channelType: getChannelType({
+              id: typeof chatId === "string" ? Number.parseInt(chatId, 10) : chatId,
+              type: "private"
+              // Default to private, will be overridden if in context
+            })
+          },
+          createdAt: sentMessage.date * 1e3
+        };
+        await this.runtime.getMemoryManager("messages").createMemory(memory);
+        memories.push(memory);
+      }
+      this.runtime.emitEvent(
+        EventTypes.MESSAGE_SENT,
+        {
+          runtime: this.runtime,
+          messages: memories,
+          roomId,
+          source: "telegram"
+        }
+      );
+      this.runtime.emitEvent(
+        "TELEGRAM_MESSAGE_SENT" /* MESSAGE_SENT */,
+        {
+          originalMessages: sentMessages,
+          chatId
+        }
+      );
+      return sentMessages;
+    } catch (error) {
+      logger.error("Error sending message to Telegram:", error);
+      return [];
+    }
+  }
 };
 
 // src/tests.ts
@@ -4459,6 +4591,14 @@ var TelegramTestSuite = class {
   bot = null;
   messageManager = null;
   tests;
+  /**
+   * Constructor for initializing a set of test cases for a Telegram bot.
+   *
+   * @constructor
+   * @property {Array<Object>} tests - An array of test cases with name and corresponding test functions.
+   * @property {string} tests.name - The name of the test case.
+   * @property {function} tests.fn - The test function to be executed.
+   */
   constructor() {
     this.tests = [
       {
@@ -4489,6 +4629,13 @@ var TelegramTestSuite = class {
    * Reference on getting the Telegram chat ID:
    * https://stackoverflow.com/a/32572159
    */
+  /**
+   * Validates the chat ID by checking if it is set in the runtime settings or environment variables.
+   * If not set, an error is thrown with a message instructing to provide a valid chat ID.
+   * @param {IAgentRuntime} runtime - The runtime object that provides access to the settings and environment variables.
+   * @throws {Error} If TELEGRAM_TEST_CHAT_ID is not set in the runtime settings or environment variables.
+   * @returns {string} The validated chat ID.
+   */
   validateChatId(runtime) {
     const testChatId = runtime.getSetting("TELEGRAM_TEST_CHAT_ID") || process.env.TELEGRAM_TEST_CHAT_ID;
     if (!testChatId) {
@@ -4531,13 +4678,17 @@ var TelegramTestSuite = class {
       const chat = await this.getChatInfo(runtime);
       const mockContext = {
         chat,
-        from: { id: "mock-user-id", username: "TestUser" },
+        from: { id: 123, username: "TestUser" },
         telegram: this.bot.telegram
       };
       const messageContent = {
         text: "Here is an image attachment:",
         attachments: [
           {
+            id: "123",
+            title: "Sample Image",
+            source: TEST_IMAGE_URL,
+            text: "Sample Image",
             url: TEST_IMAGE_URL,
             contentType: "image/png",
             description: "Sample Image"
@@ -4561,12 +4712,19 @@ var TelegramTestSuite = class {
       const chat = await this.getChatInfo(runtime);
       const mockContext = {
         chat,
-        from: { id: "mock-user-id", username: "TestUser" },
+        from: {
+          id: 123,
+          username: "TestUser",
+          is_bot: false,
+          first_name: "Test",
+          last_name: "User"
+        },
         message: {
           message_id: void 0,
           text: `@${(_a = this.bot.botInfo) == null ? void 0 : _a.username}! Hello!`,
           date: Math.floor(Date.now() / 1e3),
           chat
+          // biome-ignore lint/suspicious/noExplicitAny: <explanation>
         },
         telegram: this.bot.telegram
       };
@@ -4586,13 +4744,12 @@ var TelegramTestSuite = class {
       const fileId = await this.getFileId(chatId, TEST_IMAGE_URL);
       const mockMessage = {
         message_id: void 0,
+        chat: { id: chatId },
         date: Math.floor(Date.now() / 1e3),
         photo: [{ file_id: fileId }],
         text: `@${(_a = this.bot.botInfo) == null ? void 0 : _a.username}!`
       };
-      const { description } = await this.messageManager.processImage(
-        mockMessage
-      );
+      const { description } = await this.messageManager.processImage(mockMessage);
       if (!description) {
         throw new Error("Error processing Telegram image");
       }
@@ -4612,20 +4769,6 @@ var TelegramTestSuite = class {
   }
 };
 
-// src/constants.ts
-var MESSAGE_CONSTANTS = {
-  MAX_MESSAGES: 50,
-  RECENT_MESSAGE_COUNT: 5,
-  CHAT_HISTORY_COUNT: 10,
-  DEFAULT_SIMILARITY_THRESHOLD: 0.6,
-  DEFAULT_SIMILARITY_THRESHOLD_FOLLOW_UPS: 0.4,
-  INTEREST_DECAY_TIME: 5 * 60 * 1e3,
-  // 5 minutes
-  PARTIAL_INTEREST_DECAY: 3 * 60 * 1e3
-  // 3 minutes
-};
-var TELEGRAM_SERVICE_NAME = "telegram";
-
 // src/index.ts
 var TelegramService = class _TelegramService extends Service {
   static serviceType = TELEGRAM_SERVICE_NAME;
@@ -4633,6 +4776,11 @@ var TelegramService = class _TelegramService extends Service {
   bot;
   messageManager;
   options;
+  knownChats = /* @__PURE__ */ new Map();
+  /**
+   * Constructor for TelegramService class.
+   * @param {IAgentRuntime} runtime - The runtime object for the agent.
+   */
   constructor(runtime) {
     super(runtime);
     logger3.log("\u{1F4F1} Constructing new TelegramService...");
@@ -4646,68 +4794,234 @@ var TelegramService = class _TelegramService extends Service {
     this.messageManager = new MessageManager(this.bot, this.runtime);
     logger3.log("\u2705 TelegramService constructor completed");
   }
+  /**
+   * Starts the Telegram service for the given runtime.
+   *
+   * @param {IAgentRuntime} runtime - The agent runtime to start the Telegram service for.
+   * @returns {Promise<TelegramService>} A promise that resolves with the initialized TelegramService.
+   */
   static async start(runtime) {
     await validateTelegramConfig(runtime);
-    const tg = new _TelegramService(runtime);
-    logger3.success(
-      `\u2705 Telegram client successfully started for character ${runtime.character.name}`
-    );
-    logger3.log("\u{1F680} Starting Telegram bot...");
-    try {
-      await tg.initializeBot();
-      tg.setupMessageHandlers();
-    } catch (error) {
-      logger3.error("\u274C Failed to launch Telegram bot:", error);
-      throw error;
+    const maxRetries = 5;
+    let retryCount = 0;
+    let lastError = null;
+    while (retryCount < maxRetries) {
+      try {
+        const service = new _TelegramService(runtime);
+        logger3.success(
+          `\u2705 Telegram client successfully started for character ${runtime.character.name}`
+        );
+        logger3.log("\u{1F680} Starting Telegram bot...");
+        await service.initializeBot();
+        service.setupMessageHandlers();
+        await service.bot.telegram.getMe();
+        return service;
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error));
+        logger3.error(`Telegram initialization attempt ${retryCount + 1} failed: ${lastError.message}`);
+        retryCount++;
+        if (retryCount < maxRetries) {
+          const delay = 2 ** retryCount * 1e3;
+          logger3.info(`Retrying Telegram initialization in ${delay / 1e3} seconds...`);
+          await new Promise((resolve) => setTimeout(resolve, delay));
+        }
+      }
     }
-    return tg;
+    throw new Error(`Telegram initialization failed after ${maxRetries} attempts. Last error: ${lastError == null ? void 0 : lastError.message}`);
   }
+  /**
+   * Stops the agent runtime.
+   * @param {IAgentRuntime} runtime - The agent runtime to stop
+   */
   static async stop(runtime) {
     const tgClient = runtime.getService(TELEGRAM_SERVICE_NAME);
     if (tgClient) {
       await tgClient.stop();
     }
   }
+  /**
+   * Asynchronously stops the bot.
+   *
+   * @returns A Promise that resolves once the bot has stopped.
+   */
   async stop() {
     this.bot.stop();
   }
+  /**
+   * Initializes the Telegram bot by launching it, getting bot info, and setting up message manager.
+   * @returns {Promise<void>} A Promise that resolves when the initialization is complete.
+   */
   async initializeBot() {
     this.bot.launch({
       dropPendingUpdates: true,
       allowedUpdates: ["message", "message_reaction"]
     });
-    logger3.log("\u2728 Telegram bot successfully launched and is running!");
     const botInfo = await this.bot.telegram.getMe();
-    this.bot.botInfo = botInfo;
-    logger3.success(`Bot username: @${botInfo.username}`);
-    this.messageManager.bot = this.bot;
+    logger3.log(`Bot info: ${JSON.stringify(botInfo)}`);
+    process.once("SIGINT", () => this.bot.stop("SIGINT"));
+    process.once("SIGTERM", () => this.bot.stop("SIGTERM"));
   }
+  /**
+   * Checks if a group is authorized, based on the TELEGRAM_ALLOWED_CHATS setting.
+   * @param {Context} ctx - The context of the incoming update.
+   * @returns {Promise<boolean>} A Promise that resolves with a boolean indicating if the group is authorized.
+   */
   async isGroupAuthorized(ctx) {
-    var _a, _b, _c;
-    const config = (_a = this.runtime.character.settings) == null ? void 0 : _a.telegram;
-    if (((_b = ctx.from) == null ? void 0 : _b.id) === ((_c = ctx.botInfo) == null ? void 0 : _c.id)) {
-      return false;
+    var _a;
+    const chatId = (_a = ctx.chat) == null ? void 0 : _a.id.toString();
+    if (!chatId) return false;
+    if (!this.knownChats.has(chatId)) {
+      await this.handleNewChat(ctx);
     }
-    if (!(config == null ? void 0 : config.shouldOnlyJoinInAllowedGroups)) {
+    const allowedChats = this.runtime.getSetting("TELEGRAM_ALLOWED_CHATS");
+    if (!allowedChats) {
       return true;
     }
-    const allowedGroups = config.allowedGroupIds || [];
-    const currentGroupId = ctx.chat.id.toString();
-    if (!allowedGroups.includes(currentGroupId)) {
-      logger3.info(`Unauthorized group detected: ${currentGroupId}`);
+    try {
+      const allowedChatsList = JSON.parse(allowedChats);
+      return allowedChatsList.includes(chatId);
+    } catch (error) {
+      logger3.error("Error parsing TELEGRAM_ALLOWED_CHATS:", error);
+      return false;
+    }
+  }
+  /**
+   * Handles new chat discovery and emits WORLD_JOINED event
+   * @param {Context} ctx - The context of the incoming update
+   */
+  async handleNewChat(ctx) {
+    if (!ctx.chat) return;
+    const chat = ctx.chat;
+    const chatId = chat.id.toString();
+    this.knownChats.set(chatId, chat);
+    let chatTitle;
+    let channelType;
+    switch (chat.type) {
+      case "private":
+        chatTitle = `Chat with ${chat.first_name || "Unknown User"}`;
+        channelType = ChannelType2.DM;
+        break;
+      case "group":
+        chatTitle = chat.title || "Unknown Group";
+        channelType = ChannelType2.GROUP;
+        break;
+      case "supergroup":
+        chatTitle = chat.title || "Unknown Supergroup";
+        channelType = ChannelType2.GROUP;
+        break;
+      case "channel":
+        chatTitle = chat.title || "Unknown Channel";
+        channelType = ChannelType2.FEED;
+        break;
+      default:
+        chatTitle = "Unknown Chat";
+        channelType = ChannelType2.GROUP;
+    }
+    const worldId = createUniqueUuid2(this.runtime, chatId);
+    const roomId = createUniqueUuid2(this.runtime, chatId);
+    const world = {
+      id: worldId,
+      name: chatTitle,
+      agentId: this.runtime.agentId,
+      serverId: chatId,
+      metadata: {
+        source: "telegram",
+        ownership: { ownerId: chatId },
+        roles: {
+          [chatId]: Role.OWNER
+        }
+      }
+    };
+    const room = {
+      id: roomId,
+      name: chatTitle,
+      source: "telegram",
+      type: channelType,
+      channelId: chatId,
+      serverId: chatId,
+      worldId
+    };
+    const users = [];
+    if (chat.type === "private" && chat.id) {
+      const userId = createUniqueUuid2(this.runtime, chat.id.toString());
+      users.push({
+        id: userId,
+        names: [chat.first_name || "Unknown User"],
+        agentId: this.runtime.agentId,
+        metadata: {
+          telegram: {
+            id: chat.id.toString(),
+            username: chat.username || "unknown",
+            name: chat.first_name || "Unknown User"
+          },
+          source: "telegram"
+        }
+      });
+    } else if (chat.type === "group" || chat.type === "supergroup") {
       try {
-        await ctx.reply("Not authorized. Leaving.");
-        await ctx.leaveChat();
+        const admins = await this.bot.telegram.getChatAdministrators(chat.id);
+        if (admins && admins.length > 0) {
+          for (const admin of admins) {
+            const userId = createUniqueUuid2(this.runtime, admin.user.id.toString());
+            users.push({
+              id: userId,
+              names: [admin.user.first_name || admin.user.username || "Unknown Admin"],
+              agentId: this.runtime.agentId,
+              metadata: {
+                telegram: {
+                  id: admin.user.id.toString(),
+                  username: admin.user.username || "unknown",
+                  name: admin.user.first_name || "Unknown Admin",
+                  isAdmin: true,
+                  adminTitle: admin.custom_title || (admin.status === "creator" ? "Owner" : "Admin")
+                },
+                source: "telegram",
+                roles: [admin.status === "creator" ? Role.OWNER : Role.ADMIN]
+              }
+            });
+          }
+        }
+        try {
+          const chatInfo = await this.bot.telegram.getChat(chat.id);
+          if (chatInfo && "member_count" in chatInfo) {
+            world.metadata.memberCount = chatInfo.member_count;
+          }
+        } catch (countError) {
+          logger3.warn(`Could not get member count for chat ${chatId}: ${countError}`);
+        }
       } catch (error) {
-        logger3.error(
-          `Error leaving unauthorized group ${currentGroupId}:`,
-          error
-        );
+        logger3.warn(`Could not fetch administrators for chat ${chatId}: ${error}`);
       }
-      return false;
     }
-    return true;
+    const worldPayload = {
+      runtime: this.runtime,
+      world,
+      rooms: [room],
+      entities: users,
+      source: "telegram"
+    };
+    const telegramWorldPayload = {
+      ...worldPayload,
+      chat
+    };
+    this.runtime.emitEvent(
+      EventTypes2.WORLD_JOINED,
+      worldPayload
+    );
+    this.runtime.emitEvent(
+      "TELEGRAM_WORLD_JOINED" /* WORLD_JOINED */,
+      telegramWorldPayload
+    );
+    if (chat.type === "group" || chat.type === "supergroup") {
+      this.setupEntityTracking(chat.id);
+    }
   }
+  /**
+   * Sets up message and reaction handlers for the bot.
+   *
+   * @private
+   * @returns {void}
+   */
   setupMessageHandlers() {
     this.bot.on("message", async (ctx) => {
       try {
@@ -4726,6 +5040,120 @@ var TelegramService = class _TelegramService extends Service {
       }
     });
   }
+  /**
+   * Sets up tracking for new entities in a group chat to sync them as entities
+   * @param {number} chatId - The Telegram chat ID to track entities for
+   */
+  setupEntityTracking(chatId) {
+    const syncedEntityIds = /* @__PURE__ */ new Set();
+    this.bot.on("message", async (ctx) => {
+      if (!ctx.chat || ctx.chat.id !== chatId || !ctx.from) return;
+      const entityId = ctx.from.id.toString();
+      if (syncedEntityIds.has(entityId)) return;
+      syncedEntityIds.add(entityId);
+      const entityUuid = createUniqueUuid2(this.runtime, entityId);
+      const worldId = createUniqueUuid2(this.runtime, chatId.toString());
+      const chatIdStr = chatId.toString();
+      try {
+        await this.runtime.ensureConnection({
+          entityId: entityUuid,
+          roomId: createUniqueUuid2(this.runtime, chatIdStr),
+          userName: ctx.from.username || ctx.from.first_name || "Unknown Entity",
+          name: ctx.from.first_name || ctx.from.username || "Unknown Entity",
+          source: "telegram",
+          channelId: chatIdStr,
+          serverId: chatIdStr,
+          type: ChannelType2.GROUP,
+          worldId
+        });
+        const entityJoinedPayload = {
+          runtime: this.runtime,
+          entityId: entityUuid,
+          entity: {
+            id: entityId,
+            username: ctx.from.username || ctx.from.first_name || "Unknown Entity",
+            displayName: ctx.from.first_name || ctx.from.username || "Unknown Entity"
+          },
+          worldId,
+          source: "telegram",
+          metadata: {
+            joinedAt: Date.now()
+          }
+        };
+        const telegramEntityJoinedPayload = {
+          ...entityJoinedPayload,
+          telegramUser: {
+            id: ctx.from.id,
+            username: ctx.from.username,
+            first_name: ctx.from.first_name
+          }
+        };
+        this.runtime.emitEvent(
+          EventTypes2.ENTITY_JOINED,
+          entityJoinedPayload
+        );
+        this.runtime.emitEvent(
+          "TELEGRAM_ENTITY_JOINED" /* ENTITY_JOINED */,
+          telegramEntityJoinedPayload
+        );
+        logger3.info(`Tracked new Telegram entity: ${ctx.from.username || ctx.from.first_name || entityId}`);
+      } catch (error) {
+        logger3.error(`Error syncing new Telegram entity ${entityId} from chat ${chatId}:`, error);
+      }
+    });
+    this.bot.on("left_chat_member", async (ctx) => {
+      var _a, _b;
+      if (!((_a = ctx.message) == null ? void 0 : _a.left_chat_member) || ((_b = ctx.chat) == null ? void 0 : _b.id) !== chatId) return;
+      const leftUser = ctx.message.left_chat_member;
+      const entityId = createUniqueUuid2(this.runtime, leftUser.id.toString());
+      const chatIdStr = chatId.toString();
+      const worldId = createUniqueUuid2(this.runtime, chatIdStr);
+      try {
+        const entity = await this.runtime.getEntityById(entityId);
+        if (entity) {
+          entity.metadata = {
+            ...entity.metadata,
+            status: "INACTIVE",
+            leftAt: Date.now()
+          };
+          await this.runtime.updateEntity(entity);
+          const entityLeftPayload = {
+            runtime: this.runtime,
+            entityId,
+            entity: {
+              id: leftUser.id.toString(),
+              username: leftUser.username || leftUser.first_name || "Unknown Entity",
+              displayName: leftUser.first_name || leftUser.username || "Unknown Entity"
+            },
+            worldId,
+            source: "telegram",
+            metadata: {
+              leftAt: Date.now()
+            }
+          };
+          const telegramEntityLeftPayload = {
+            ...entityLeftPayload,
+            telegramUser: {
+              id: leftUser.id,
+              username: leftUser.username,
+              first_name: leftUser.first_name
+            }
+          };
+          this.runtime.emitEvent(
+            EventTypes2.ENTITY_LEFT,
+            entityLeftPayload
+          );
+          this.runtime.emitEvent(
+            "TELEGRAM_ENTITY_LEFT" /* ENTITY_LEFT */,
+            telegramEntityLeftPayload
+          );
+          logger3.info(`Entity ${leftUser.username || leftUser.first_name || leftUser.id} left chat ${chatId}`);
+        }
+      } catch (error) {
+        logger3.error(`Error handling Telegram entity leaving chat ${chatId}:`, error);
+      }
+    });
+  }
 };
 var telegramPlugin = {
   name: TELEGRAM_SERVICE_NAME,