@elizaos/plugin-telegram 1.0.0-alpha.4 → 1.0.0-alpha.7

package/dist/index.js

@@ -5,6 +5,20 @@ import {
 } 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 +4088,10 @@ ${errorMessages}`
 // src/messageManager.ts
 import {
   ChannelType,
-  createUniqueUuid,
-  logger,
   ModelTypes,
-  Role
+  Role,
+  createUniqueUuid,
+  logger
 } from "@elizaos/core";
 
 // src/utils.ts
@@ -4106,11 +4120,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 +4166,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 +4221,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 +4270,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 +4292,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;
@@ -4379,6 +4434,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;
@@ -4459,6 +4519,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 +4557,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 +4606,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 +4640,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 +4672,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 +4697,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 +4704,10 @@ var TelegramService = class _TelegramService extends Service {
   bot;
   messageManager;
   options;
+  /**
+   * 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,6 +4721,12 @@ 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);
@@ -4662,15 +4743,28 @@ var TelegramService = class _TelegramService extends Service {
     }
     return tg;
   }
+  /**
+   * 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,
@@ -4682,6 +4776,12 @@ var TelegramService = class _TelegramService extends Service {
     logger3.success(`Bot username: @${botInfo.username}`);
     this.messageManager.bot = this.bot;
   }
+  /**
+   * 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.
+   */
   async isGroupAuthorized(ctx) {
     var _a, _b, _c;
     const config = (_a = this.runtime.character.settings) == null ? void 0 : _a.telegram;
@@ -4708,6 +4808,12 @@ var TelegramService = class _TelegramService extends Service {
     }
     return true;
   }
+  /**
+   * Set up message handlers for the bot.
+   *
+   * @private
+   * @returns {void}
+   */
   setupMessageHandlers() {
     this.bot.on("message", async (ctx) => {
       try {