@elizaos/plugin-telegram 1.0.2 → 1.0.9

package/dist/index.js

@@ -23,27 +23,6 @@ import {
 } from "@elizaos/core";
 import { Telegraf } from "telegraf";
 
-// src/environment.ts
-import { z } from "zod";
-var telegramEnvSchema = z.object({
-  TELEGRAM_BOT_TOKEN: z.string().min(1, "Telegram bot token is required")
-});
-async function validateTelegramConfig(runtime) {
-  try {
-    const config = {
-      TELEGRAM_BOT_TOKEN: runtime.getSetting("TELEGRAM_BOT_TOKEN") || process.env.TELEGRAM_BOT_TOKEN
-    };
-    return telegramEnvSchema.parse(config);
-  } catch (error) {
-    if (error instanceof z.ZodError) {
-      const errorMessages = error.errors.map((err) => `${err.path.join(".")}: ${err.message}`).join("\n");
-      throw new Error(`Telegram configuration validation failed:
-${errorMessages}`);
-    }
-    throw error;
-  }
-}
-
 // src/messageManager.ts
 import {
   ChannelType,
@@ -87,46 +66,46 @@ function convertMarkdownToTelegram(markdown) {
     return placeholder;
   }
   let converted = markdown;
-  converted = converted.replace(/```(\w+)?\n([\s\S]*?)```/g, (match, lang, code) => {
+  converted = converted.replace(/```(\w+)?\n([\s\S]*?)```/g, (_match, lang, code) => {
     const escapedCode = escapeCode(code);
     const formatted = "```" + (lang || "") + "\n" + escapedCode + "```";
     return storeReplacement(formatted);
   });
-  converted = converted.replace(/`([^`]+)`/g, (match, code) => {
+  converted = converted.replace(/`([^`]+)`/g, (_match, code) => {
     const escapedCode = escapeCode(code);
     const formatted = "`" + escapedCode + "`";
     return storeReplacement(formatted);
   });
   converted = converted.replace(
     /$begin:math:display$([^$end:math:display$]+)]$begin:math:text$([^)]+)$end:math:text$/g,
-    (match, text, url) => {
+    (_match, text, url) => {
       const formattedText = escapePlainText(text);
       const escapedURL = escapeUrl(url);
       const formatted = `[${formattedText}](${escapedURL})`;
       return storeReplacement(formatted);
     }
   );
-  converted = converted.replace(/\*\*([^*]+)\*\*/g, (match, content) => {
+  converted = converted.replace(/\*\*([^*]+)\*\*/g, (_match, content) => {
     const formattedContent = escapePlainText(content);
     const formatted = `*${formattedContent}*`;
     return storeReplacement(formatted);
   });
-  converted = converted.replace(/~~([^~]+)~~/g, (match, content) => {
+  converted = converted.replace(/~~([^~]+)~~/g, (_match, content) => {
     const formattedContent = escapePlainText(content);
     const formatted = `~${formattedContent}~`;
     return storeReplacement(formatted);
   });
-  converted = converted.replace(/(?<!\*)\*([^*\n]+)\*(?!\*)/g, (match, content) => {
+  converted = converted.replace(/(?<!\*)\*([^*\n]+)\*(?!\*)/g, (_match, content) => {
     const formattedContent = escapePlainText(content);
     const formatted = `_${formattedContent}_`;
     return storeReplacement(formatted);
   });
-  converted = converted.replace(/_([^_\n]+)_/g, (match, content) => {
+  converted = converted.replace(/_([^_\n]+)_/g, (_match, content) => {
     const formattedContent = escapePlainText(content);
     const formatted = `_${formattedContent}_`;
     return storeReplacement(formatted);
   });
-  converted = converted.replace(/^(#{1,6})\s*(.*)$/gm, (match, hashes, headerContent) => {
+  converted = converted.replace(/^(#{1,6})\s*(.*)$/gm, (_match, _hashes, headerContent) => {
     const formatted = `*${escapePlainText(headerContent.trim())}*`;
     return storeReplacement(formatted);
   });
@@ -196,7 +175,7 @@ var MessageManager = class {
   async processImage(message) {
     try {
       let imageUrl = null;
-      logger.info(`Telegram Message: ${message}`);
+      logger.info(`Telegram Message: ${JSON.stringify(message, null, 2)}`);
       if ("photo" in message && message.photo?.length > 0) {
         const photo = message.photo[message.photo.length - 1];
         const fileLink = await this.bot.telegram.getFileLink(photo.file_id);
@@ -370,10 +349,8 @@ ${description}]` };
         logger.error("handleMessage: ctx.chat is undefined");
         return;
       }
-      const roomId = createUniqueUuid(
-        this.runtime,
-        threadId ? `${ctx.chat.id}-${threadId}` : ctx.chat.id.toString()
-      );
+      const telegramRoomid = threadId ? `${ctx.chat.id}-${threadId}` : ctx.chat.id.toString();
+      const roomId = createUniqueUuid(this.runtime, telegramRoomid);
       const messageId = createUniqueUuid(this.runtime, message?.message_id?.toString());
       const imageInfo = await this.processImage(message);
       let messageText = "";
@@ -386,6 +363,19 @@ ${description}]` };
       if (!fullText) return;
       const chat = message.chat;
       const channelType = getChannelType(chat);
+      const sourceId = createUniqueUuid(this.runtime, "" + chat.id);
+      await this.runtime.ensureConnection({
+        entityId,
+        roomId,
+        userName: ctx.from.username,
+        name: ctx.from.first_name,
+        source: "telegram",
+        channelId: telegramRoomid,
+        serverId: void 0,
+        type: channelType,
+        worldId: createUniqueUuid(this.runtime, roomId),
+        worldName: telegramRoomid
+      });
       const memory = {
         id: messageId,
         entityId,
@@ -393,21 +383,45 @@ ${description}]` };
         roomId,
         content: {
           text: fullText,
+          // attachments?
           source: "telegram",
+          // url?
           channelType,
           inReplyTo: "reply_to_message" in message && message.reply_to_message ? createUniqueUuid(this.runtime, message.reply_to_message.message_id.toString()) : void 0
         },
+        metadata: {
+          entityName: ctx.from.first_name,
+          entityUserName: ctx.from.username,
+          fromBot: ctx.from.is_bot,
+          // include very technical/exact reference to this user for security reasons
+          // don't remove or change this, spartan needs this
+          fromId: chat.id,
+          sourceId,
+          // why message? all Memories contain content (which is basically a message)
+          // what are the other types? see MemoryType
+          type: "message"
+          // MemoryType.MESSAGE
+          // scope: `shared`, `private`, or `room`
+        },
         createdAt: message.date * 1e3
       };
       const callback = async (content, _files) => {
         try {
           if (!content.text) return [];
-          const sentMessages = await this.sendMessageInChunks(ctx, content, message.message_id);
-          if (!sentMessages) return [];
+          let sentMessages = false;
+          if (content?.channelType === "DM") {
+            sentMessages = [];
+            if (ctx.from) {
+              const res = await this.bot.telegram.sendMessage(ctx.from.id, content.text);
+              sentMessages.push(res);
+            }
+          } else {
+            sentMessages = await this.sendMessageInChunks(ctx, content, message.message_id);
+          }
+          if (!Array.isArray(sentMessages)) return [];
           const memories = [];
           for (let i = 0; i < sentMessages.length; i++) {
             const sentMessage = sentMessages[i];
-            const _isLastMessage = i === sentMessages.length - 1;
             const responseMemory = {
               id: createUniqueUuid(this.runtime, sentMessage.message_id.toString()),
               entityId: this.runtime.agentId,
@@ -622,15 +636,27 @@ var TelegramService = class _TelegramService extends Service {
   constructor(runtime) {
     super(runtime);
     logger2.log("\u{1F4F1} Constructing new TelegramService...");
+    const botToken = runtime.getSetting("TELEGRAM_BOT_TOKEN");
+    if (!botToken || botToken.trim() === "") {
+      logger2.warn("Telegram Bot Token not provided - Telegram functionality will be unavailable");
+      this.bot = null;
+      this.messageManager = null;
+      return;
+    }
     this.options = {
       telegram: {
         apiRoot: runtime.getSetting("TELEGRAM_API_ROOT") || process.env.TELEGRAM_API_ROOT || "https://api.telegram.org"
       }
     };
-    const botToken = runtime.getSetting("TELEGRAM_BOT_TOKEN");
-    this.bot = new Telegraf(botToken, this.options);
-    this.messageManager = new MessageManager(this.bot, this.runtime);
-    logger2.log("\u2705 TelegramService constructor completed");
+    try {
+      this.bot = new Telegraf(botToken, this.options);
+      this.messageManager = new MessageManager(this.bot, this.runtime);
+      logger2.log("\u2705 TelegramService constructor completed");
+    } catch (error) {
+      logger2.error(`Error initializing Telegram bot: ${error instanceof Error ? error.message : String(error)}`);
+      this.bot = null;
+      this.messageManager = null;
+    }
   }
   /**
    * Starts the Telegram service for the given runtime.
@@ -639,13 +665,16 @@ var TelegramService = class _TelegramService extends Service {
    * @returns {Promise<TelegramService>} A promise that resolves with the initialized TelegramService.
    */
   static async start(runtime) {
-    await validateTelegramConfig(runtime);
+    const service = new _TelegramService(runtime);
+    if (!service.bot) {
+      logger2.warn("Telegram service started without bot functionality - no bot token provided");
+      return service;
+    }
     const maxRetries = 5;
     let retryCount = 0;
     let lastError = null;
     while (retryCount < maxRetries) {
       try {
-        const service = new _TelegramService(runtime);
         logger2.success(
           `\u2705 Telegram client successfully started for character ${runtime.character.name}`
         );
@@ -668,9 +697,10 @@ var TelegramService = class _TelegramService extends Service {
         }
       }
     }
-    throw new Error(
-      `Telegram initialization failed after ${maxRetries} attempts. Last error: ${lastError?.message}`
+    logger2.error(
+      `Telegram initialization failed after ${maxRetries} attempts. Last error: ${lastError?.message}. Service will continue without Telegram functionality.`
     );
+    return service;
   }
   /**
    * Stops the agent runtime.
@@ -688,21 +718,27 @@ var TelegramService = class _TelegramService extends Service {
    * @returns A Promise that resolves once the bot has stopped.
    */
   async stop() {
-    this.bot.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({
+    this.bot?.start((ctx) => {
+      this.runtime.emitEvent(["TELEGRAM_SLASH_START" /* SLASH_START */], {
+        // we don't need this
+        ctx
+      });
+    });
+    this.bot?.launch({
       dropPendingUpdates: true,
       allowedUpdates: ["message", "message_reaction"]
     });
     const botInfo = await this.bot.telegram.getMe();
     logger2.log(`Bot info: ${JSON.stringify(botInfo)}`);
-    process.once("SIGINT", () => this.bot.stop("SIGINT"));
-    process.once("SIGTERM", () => this.bot.stop("SIGTERM"));
+    process.once("SIGINT", () => this.bot?.stop("SIGINT"));
+    process.once("SIGTERM", () => this.bot?.stop("SIGTERM"));
   }
   /**
    * Sets up the middleware chain for preprocessing messages before they reach handlers.
@@ -720,8 +756,8 @@ var TelegramService = class _TelegramService extends Service {
    * @private
    */
   setupMiddlewares() {
-    this.bot.use(this.authorizationMiddleware.bind(this));
-    this.bot.use(this.chatAndEntityMiddleware.bind(this));
+    this.bot?.use(this.authorizationMiddleware.bind(this));
+    this.bot?.use(this.chatAndEntityMiddleware.bind(this));
   }
   /**
    * Authorization middleware - checks if chat is allowed to interact with the bot
@@ -788,14 +824,14 @@ var TelegramService = class _TelegramService extends Service {
    * @private
    */
   setupMessageHandlers() {
-    this.bot.on("message", async (ctx) => {
+    this.bot?.on("message", async (ctx) => {
       try {
         await this.messageManager.handleMessage(ctx);
       } catch (error) {
         logger2.error("Error handling message:", error);
       }
     });
-    this.bot.on("message_reaction", async (ctx) => {
+    this.bot?.on("message_reaction", async (ctx) => {
       try {
         await this.messageManager.handleReaction(ctx);
       } catch (error) {
@@ -1074,7 +1110,7 @@ var TelegramService = class _TelegramService extends Service {
       entities,
       source: "telegram",
       chat,
-      botUsername: this.bot.botInfo.username
+      botUsername: this.bot?.botInfo?.username
     };
     if (chat.type !== "private") {
       await this.runtime.emitEvent("TELEGRAM_WORLD_JOINED" /* WORLD_JOINED */, telegramWorldPayload);
@@ -1107,12 +1143,13 @@ var TelegramService = class _TelegramService extends Service {
         entityBatch.map(async (entity) => {
           try {
             if (entity.id) {
+              const telegramMetadata = entity.metadata?.telegram;
               await this.runtime.ensureConnection({
                 entityId: entity.id,
                 roomId,
-                userName: entity.metadata?.telegram?.username,
-                name: entity.metadata?.telegram?.name,
-                userId: entity.metadata?.telegram?.id,
+                userName: telegramMetadata?.username,
+                name: telegramMetadata?.name,
+                userId: telegramMetadata?.id,
                 source: "telegram",
                 channelId,
                 serverId,
@@ -1125,7 +1162,8 @@ var TelegramService = class _TelegramService extends Service {
               );
             }
           } catch (err) {
-            logger2.warn(`Failed to sync user ${entity.metadata?.telegram?.username}: ${err}`);
+            const telegramMetadata = entity.metadata?.telegram;
+            logger2.warn(`Failed to sync user ${telegramMetadata?.username}: ${err}`);
           }
         })
       );
@@ -1197,7 +1235,7 @@ var TelegramService = class _TelegramService extends Service {
         this.syncedEntityIds.add(userId);
       } else if (chat.type === "group" || chat.type === "supergroup") {
         try {
-          const admins = await this.bot.telegram.getChatAdministrators(chat.id);
+          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());
@@ -1284,15 +1322,21 @@ var TelegramService = class _TelegramService extends Service {
     }
   }
   static registerSendHandlers(runtime, serviceInstance) {
-    if (serviceInstance) {
+    if (serviceInstance && serviceInstance.bot) {
       runtime.registerSendHandler(
         "telegram",
         serviceInstance.handleSendMessage.bind(serviceInstance)
       );
       logger2.info("[Telegram] Registered send handler.");
+    } else {
+      logger2.warn("[Telegram] Cannot register send handler - bot not initialized.");
     }
   }
   async handleSendMessage(runtime, target, content) {
+    if (!this.bot || !this.messageManager) {
+      logger2.error("[Telegram SendHandler] Bot not initialized - cannot send messages.");
+      throw new Error("Telegram bot is not initialized. Please provide TELEGRAM_BOT_TOKEN.");
+    }
     let chatId;
     if (target.channelId) {
       chatId = target.channelId;
@@ -1406,6 +1450,9 @@ var TelegramTestSuite = class {
   }
   async testCreatingTelegramBot(runtime) {
     this.telegramClient = runtime.getService("telegram");
+    if (!this.telegramClient || !this.telegramClient.messageManager) {
+      throw new Error("Telegram service or message manager not initialized - check TELEGRAM_BOT_TOKEN");
+    }
     this.bot = this.telegramClient.messageManager.bot;
     this.messageManager = this.telegramClient.messageManager;
     logger3.debug("Telegram bot initialized successfully.");