@elizaos/plugin-telegram 1.0.4 → 1.0.10

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);
   });
@@ -159,7 +138,7 @@ function convertToTelegramButtons(buttons) {
 }
 
 // src/messageManager.ts
-import fs from "node:fs";
+import fs from "fs";
 var MAX_MESSAGE_LENGTH = 4096;
 var getChannelType = (chat) => {
   switch (chat.type) {
@@ -325,9 +304,10 @@ ${description}]` };
       );
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
-      logger.error(`Failed to send ${type}. Path: ${mediaPath}. Error: ${errorMessage}`, {
-        originalError: error
-      });
+      logger.error(
+        { originalError: error },
+        `Failed to send ${type}. Path: ${mediaPath}. Error: ${errorMessage}`
+      );
       throw error;
     }
   }
@@ -384,6 +364,7 @@ ${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,
@@ -405,6 +386,7 @@ ${description}]` };
           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
         },
@@ -415,9 +397,12 @@ ${description}]` };
           // 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?
+          // what are the other types? see MemoryType
           type: "message"
+          // MemoryType.MESSAGE
+          // scope: `shared`, `private`, or `room`
         },
         createdAt: message.date * 1e3
       };
@@ -425,7 +410,7 @@ ${description}]` };
         try {
           if (!content.text) return [];
           let sentMessages = false;
-          if (content?.target === "DM") {
+          if (content?.channelType === "DM") {
             sentMessages = [];
             if (ctx.from) {
               const res = await this.bot.telegram.sendMessage(ctx.from.id, content.text);
@@ -438,7 +423,6 @@ ${description}]` };
           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,
@@ -458,7 +442,7 @@ ${description}]` };
           }
           return memories;
         } catch (error) {
-          logger.error("Error in message callback:", error);
+          logger.error({ error }, "Error in message callback");
           return [];
         }
       };
@@ -477,12 +461,15 @@ ${description}]` };
         originalMessage: message
       });
     } catch (error) {
-      logger.error("Error handling Telegram message:", {
-        error,
-        chatId: ctx.chat?.id,
-        messageId: ctx.message?.message_id,
-        from: ctx.from?.username || ctx.from?.id
-      });
+      logger.error(
+        {
+          error,
+          chatId: ctx.chat?.id,
+          messageId: ctx.message?.message_id,
+          from: ctx.from?.username || ctx.from?.id
+        },
+        "Error handling Telegram message"
+      );
       throw error;
     }
   }
@@ -540,7 +527,7 @@ ${description}]` };
           };
           return [responseMemory];
         } catch (error) {
-          logger.error("Error in reaction callback:", error);
+          logger.error({ error }, "Error in reaction callback");
           return [];
         }
       };
@@ -568,7 +555,13 @@ ${description}]` };
       });
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
-      logger.error("Error handling reaction:", { error: errorMessage, originalError: error });
+      logger.error(
+        {
+          error: errorMessage,
+          originalError: error
+        },
+        "Error handling reaction"
+      );
     }
   }
   /**
@@ -628,10 +621,13 @@ ${description}]` };
       return sentMessages;
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
-      logger.error("Error sending message to Telegram:", {
-        error: errorMessage,
-        originalError: error
-      });
+      logger.error(
+        {
+          error: errorMessage,
+          originalError: error
+        },
+        "Error sending message to Telegram"
+      );
       return [];
     }
   }
@@ -653,15 +649,29 @@ 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.
@@ -670,13 +680,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}`
         );
@@ -699,9 +712,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.
@@ -719,21 +733,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.
@@ -751,8 +771,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
@@ -805,7 +825,7 @@ var TelegramService = class _TelegramService extends Service {
       try {
         await this.handleForumTopic(ctx);
       } catch (error) {
-        logger2.error(`Error handling forum topic: ${error}`);
+        logger2.error({ error }, `Error handling forum topic: ${error}`);
       }
     }
     if (ctx.from && ctx.chat.type !== "private") {
@@ -819,18 +839,18 @@ 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);
+        logger2.error({ error }, "Error handling message");
       }
     });
-    this.bot.on("message_reaction", async (ctx) => {
+    this.bot?.on("message_reaction", async (ctx) => {
       try {
         await this.messageManager.handleReaction(ctx);
       } catch (error) {
-        logger2.error("Error handling reaction:", error);
+        logger2.error({ error }, "Error handling reaction");
       }
     });
   }
@@ -850,7 +870,7 @@ var TelegramService = class _TelegramService extends Service {
       const allowedChatsList = JSON.parse(allowedChats);
       return allowedChatsList.includes(chatId);
     } catch (error) {
-      logger2.error("Error parsing TELEGRAM_ALLOWED_CHATS:", error);
+      logger2.error({ error }, "Error parsing TELEGRAM_ALLOWED_CHATS");
       return false;
     }
   }
@@ -1105,7 +1125,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);
@@ -1230,7 +1250,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());
@@ -1317,15 +1337,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;
@@ -1350,11 +1376,11 @@ var TelegramService = class _TelegramService extends Service {
       logger2.info(`[Telegram SendHandler] Message sent to chat ID: ${chatId}`);
     } catch (error) {
       logger2.error(
-        `[Telegram SendHandler] Error sending message: ${error instanceof Error ? error.message : String(error)}`,
         {
           target,
           content
-        }
+        },
+        `[Telegram SendHandler] Error sending message: ${error instanceof Error ? error.message : String(error)}`
       );
       throw error;
     }
@@ -1439,6 +1465,11 @@ 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.");
@@ -1477,7 +1508,10 @@ var TelegramTestSuite = class {
           }
         ]
       };
-      await this.messageManager.sendMessageInChunks(mockContext, messageContent);
+      await this.messageManager.sendMessageInChunks(
+        mockContext,
+        messageContent
+      );
       logger3.success("Message with image attachment sent successfully.");
     } catch (error) {
       throw new Error(`Error sending Telegram message with attachment: ${error}`);
@@ -1555,7 +1589,7 @@ var TelegramTestSuite = class {
       }
       return message.photo[message.photo.length - 1].file_id;
     } catch (error) {
-      logger3.error(`Error sending image: ${error}`);
+      logger3.error({ error }, `Error sending image: ${error}`);
       throw error;
     }
   }