@elizaos/plugin-telegram 1.0.0-alpha.20 → 1.0.0-alpha.22

package/dist/index.js

@@ -1,6 +1,10 @@
 // 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";
@@ -4088,8 +4092,8 @@ ${errorMessages}`
 // src/messageManager.ts
 import {
   ChannelType,
+  EventTypes,
   ModelTypes,
-  Role,
   createUniqueUuid,
   logger
 } from "@elizaos/core";
@@ -4322,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,
@@ -4352,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,
@@ -4365,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(
@@ -4407,7 +4392,7 @@ ${description}]` };
                 ...content,
                 text: sentMessage.text,
                 inReplyTo: messageId,
-                channelType: getChannelType(message.chat)
+                channelType
               },
               createdAt: sentMessage.date * 1e3
             };
@@ -4421,11 +4406,23 @@ ${description}]` };
         }
       };
       this.runtime.emitEvent(
-        ["TELEGRAM_MESSAGE_RECEIVED", "MESSAGE_RECEIVED"],
+        EventTypes.MESSAGE_RECEIVED,
         {
           runtime: this.runtime,
           message: memory,
-          callback
+          callback,
+          source: "telegram"
+        }
+      );
+      this.runtime.emitEvent(
+        "TELEGRAM_MESSAGE_RECEIVED" /* MESSAGE_RECEIVED */,
+        {
+          runtime: this.runtime,
+          message: memory,
+          callback,
+          source: "telegram",
+          ctx,
+          originalMessage: message
         }
       );
     } catch (error) {
@@ -4450,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()}`
@@ -4463,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()
@@ -4472,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);
@@ -4497,17 +4492,94 @@ ${description}]` };
         }
       };
       this.runtime.emitEvent(
-        ["TELEGRAM_REACTION_RECEIVED", "REACTION_RECEIVED"],
+        EventTypes.REACTION_RECEIVED,
         {
           runtime: this.runtime,
           message: memory,
-          callback
+          callback,
+          source: "telegram"
+        }
+      );
+      this.runtime.emitEvent(
+        "TELEGRAM_REACTION_RECEIVED" /* REACTION_RECEIVED */,
+        {
+          runtime: this.runtime,
+          message: memory,
+          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
@@ -4704,6 +4776,7 @@ 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.
@@ -4729,19 +4802,32 @@ var TelegramService = class _TelegramService extends Service {
    */
   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.
@@ -4770,46 +4856,168 @@ var TelegramService = class _TelegramService extends Service {
       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 the group is authorized based on the Telegram settings.
-   *
-   * @param {Context} ctx - The context object representing the incoming message.
-   * @returns {Promise<boolean>} A Promise that resolves to a boolean indicating if the group is authorized.
+   * 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);
+    }
   }
   /**
-   * Set up message handlers for the bot.
+   * Sets up message and reaction handlers for the bot.
    *
    * @private
    * @returns {void}
@@ -4832,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,