@elizaos/plugin-telegram 1.0.9 → 1.6.2

package/dist/index.js

@@ -19,7 +19,7 @@ import {
   Role,
   Service,
   createUniqueUuid as createUniqueUuid2,
-  logger as logger2
+  logger as logger3
 } from "@elizaos/core";
 import { Telegraf } from "telegraf";
 
@@ -28,13 +28,15 @@ import {
   ChannelType,
   EventType,
   ModelType,
+  ServiceType,
   createUniqueUuid,
-  logger
+  logger as logger2
 } from "@elizaos/core";
 import { Markup as Markup2 } from "telegraf";
 
 // src/utils.ts
 import { Markup } from "telegraf";
+import { logger } from "@elizaos/core";
 var TELEGRAM_RESERVED_REGEX = /([_*[\]()~`>#+\-=|{}.!\\])/g;
 function escapePlainText(text) {
   if (!text) return "";
@@ -127,18 +129,36 @@ function convertMarkdownToTelegram(markdown) {
 }
 function convertToTelegramButtons(buttons) {
   if (!buttons) return [];
-  return buttons.map((button) => {
+  const telegramButtons = [];
+  for (const button of buttons) {
+    if (!button || !button.text || !button.url) {
+      logger.warn({ button }, "Invalid button configuration, skipping");
+      continue;
+    }
+    let telegramButton;
     switch (button.kind) {
       case "login":
-        return Markup.button.login(button.text, button.url);
+        telegramButton = Markup.button.login(button.text, button.url);
+        break;
       case "url":
-        return Markup.button.url(button.text, button.url);
+        telegramButton = Markup.button.url(button.text, button.url);
+        break;
+      default:
+        logger.warn(`Unknown button kind '${button.kind}', treating as URL button`);
+        telegramButton = Markup.button.url(button.text, button.url);
+        break;
     }
-  });
+    telegramButtons.push(telegramButton);
+  }
+  return telegramButtons;
+}
+function cleanText(text) {
+  if (!text) return "";
+  return text.split("\0").join("");
 }
 
 // src/messageManager.ts
-import fs from "node:fs";
+import fs from "fs";
 var MAX_MESSAGE_LENGTH = 4096;
 var getChannelType = (chat) => {
   switch (chat.type) {
@@ -165,7 +185,6 @@ var MessageManager = class {
     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.
    *
@@ -175,12 +194,12 @@ var MessageManager = class {
   async processImage(message) {
     try {
       let imageUrl = null;
-      logger.info(`Telegram Message: ${JSON.stringify(message, null, 2)}`);
+      logger2.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);
         imageUrl = fileLink.toString();
-      } else if ("document" in message && message.document?.mime_type?.startsWith("image/")) {
+      } else if ("document" in message && message.document?.mime_type?.startsWith("image/") && !message.document?.mime_type?.startsWith("application/pdf")) {
         const fileLink = await this.bot.telegram.getFileLink(message.document.file_id);
         imageUrl = fileLink.toString();
       }
@@ -197,7 +216,237 @@ ${description}]` };
     }
     return null;
   }
-  // Send long messages in chunks
+  /**
+   * Process a document from a Telegram message to extract the document URL and description.
+   * Handles PDFs and other document types by converting them to text when possible.
+   *
+   * @param {Message} message - The Telegram message object containing the document.
+   * @returns {Promise<{ description: string } | null>} The description of the processed document or null if no document found.
+   */
+  async processDocument(message) {
+    try {
+      if (!("document" in message) || !message.document) {
+        return null;
+      }
+      const document = message.document;
+      const fileLink = await this.bot.telegram.getFileLink(document.file_id);
+      const documentUrl = fileLink.toString();
+      logger2.info(
+        `Processing document: ${document.file_name} (${document.mime_type}, ${document.file_size} bytes)`
+      );
+      const documentProcessor = this.getDocumentProcessor(document.mime_type);
+      if (documentProcessor) {
+        return await documentProcessor(document, documentUrl);
+      }
+      return {
+        title: `Document: ${document.file_name || "Unknown Document"}`,
+        fullText: "",
+        formattedDescription: `[Document: ${document.file_name || "Unknown Document"}
+Type: ${document.mime_type || "unknown"}
+Size: ${document.file_size || 0} bytes]`,
+        fileName: document.file_name || "Unknown Document",
+        mimeType: document.mime_type,
+        fileSize: document.file_size
+      };
+    } catch (error) {
+      logger2.error({ error }, "Error processing document");
+      return null;
+    }
+  }
+  /**
+   * Get the appropriate document processor based on MIME type.
+   */
+  getDocumentProcessor(mimeType) {
+    if (!mimeType) return null;
+    const processors = {
+      "application/pdf": this.processPdfDocument.bind(this),
+      "text/": this.processTextDocument.bind(this),
+      // covers text/plain, text/csv, text/markdown, etc.
+      "application/json": this.processTextDocument.bind(this)
+    };
+    for (const [pattern, processor] of Object.entries(processors)) {
+      if (mimeType.startsWith(pattern)) {
+        return processor;
+      }
+    }
+    return null;
+  }
+  /**
+   * Process PDF documents by converting them to text.
+   */
+  async processPdfDocument(document, documentUrl) {
+    try {
+      const pdfService = this.runtime.getService(ServiceType.PDF);
+      if (!pdfService) {
+        logger2.warn("PDF service not available, using fallback");
+        return {
+          title: `PDF Document: ${document.file_name || "Unknown Document"}`,
+          fullText: "",
+          formattedDescription: `[PDF Document: ${document.file_name || "Unknown Document"}
+Size: ${document.file_size || 0} bytes
+Unable to extract text content]`,
+          fileName: document.file_name || "Unknown Document",
+          mimeType: document.mime_type,
+          fileSize: document.file_size
+        };
+      }
+      const response = await fetch(documentUrl);
+      if (!response.ok) {
+        throw new Error(`Failed to fetch PDF: ${response.status}`);
+      }
+      const pdfBuffer = await response.arrayBuffer();
+      const text = await pdfService.convertPdfToText(Buffer.from(pdfBuffer));
+      logger2.info(`PDF processed successfully: ${text.length} characters extracted`);
+      return {
+        title: document.file_name || "Unknown Document",
+        fullText: text,
+        formattedDescription: `[PDF Document: ${document.file_name || "Unknown Document"}
+Size: ${document.file_size || 0} bytes
+Text extracted successfully: ${text.length} characters]`,
+        fileName: document.file_name || "Unknown Document",
+        mimeType: document.mime_type,
+        fileSize: document.file_size
+      };
+    } catch (error) {
+      logger2.error({ error }, "Error processing PDF document");
+      return {
+        title: `PDF Document: ${document.file_name || "Unknown Document"}`,
+        fullText: "",
+        formattedDescription: `[PDF Document: ${document.file_name || "Unknown Document"}
+Size: ${document.file_size || 0} bytes
+Error: Unable to extract text content]`,
+        fileName: document.file_name || "Unknown Document",
+        mimeType: document.mime_type,
+        fileSize: document.file_size
+      };
+    }
+  }
+  /**
+   * Process text documents by fetching their content.
+   */
+  async processTextDocument(document, documentUrl) {
+    try {
+      const response = await fetch(documentUrl);
+      if (!response.ok) {
+        throw new Error(`Failed to fetch text document: ${response.status}`);
+      }
+      const text = await response.text();
+      logger2.info(`Text document processed successfully: ${text.length} characters extracted`);
+      return {
+        title: document.file_name || "Unknown Document",
+        fullText: text,
+        formattedDescription: `[Text Document: ${document.file_name || "Unknown Document"}
+Size: ${document.file_size || 0} bytes
+Text extracted successfully: ${text.length} characters]`,
+        fileName: document.file_name || "Unknown Document",
+        mimeType: document.mime_type,
+        fileSize: document.file_size
+      };
+    } catch (error) {
+      logger2.error({ error }, "Error processing text document");
+      return {
+        title: `Text Document: ${document.file_name || "Unknown Document"}`,
+        fullText: "",
+        formattedDescription: `[Text Document: ${document.file_name || "Unknown Document"}
+Size: ${document.file_size || 0} bytes
+Error: Unable to read content]`,
+        fileName: document.file_name || "Unknown Document",
+        mimeType: document.mime_type,
+        fileSize: document.file_size
+      };
+    }
+  }
+  /**
+   * Processes the message content, documents, and images to generate
+   * processed content and media attachments.
+   *
+   * @param {Message} message The message to process
+   * @returns {Promise<{ processedContent: string; attachments: Media[] }>} Processed content and media attachments
+   */
+  async processMessage(message) {
+    let processedContent = "";
+    let attachments = [];
+    if ("text" in message && message.text) {
+      processedContent = message.text;
+    } else if ("caption" in message && message.caption) {
+      processedContent = message.caption;
+    }
+    if ("document" in message && message.document) {
+      const document = message.document;
+      const documentInfo = await this.processDocument(message);
+      if (documentInfo) {
+        try {
+          const fileLink = await this.bot.telegram.getFileLink(document.file_id);
+          const title = documentInfo.title;
+          const fullText = documentInfo.fullText;
+          if (fullText) {
+            const documentContent = `
+
+--- DOCUMENT CONTENT ---
+Title: ${title}
+
+Full Content:
+${fullText}
+--- END DOCUMENT ---
+
+`;
+            processedContent += documentContent;
+          }
+          attachments.push({
+            id: document.file_id,
+            url: fileLink.toString(),
+            title,
+            source: document.mime_type?.startsWith("application/pdf") ? "PDF" : "Document",
+            description: documentInfo.formattedDescription,
+            text: fullText
+          });
+          logger2.info(`Document processed successfully: ${documentInfo.fileName}`);
+        } catch (error) {
+          logger2.error({ error }, `Error processing document ${documentInfo.fileName}`);
+          attachments.push({
+            id: document.file_id,
+            url: "",
+            title: `Document: ${documentInfo.fileName}`,
+            source: "Document",
+            description: `Document processing failed: ${documentInfo.fileName}`,
+            text: `Document: ${documentInfo.fileName}
+Size: ${documentInfo.fileSize || 0} bytes
+Type: ${documentInfo.mimeType || "unknown"}`
+          });
+        }
+      } else {
+        attachments.push({
+          id: document.file_id,
+          url: "",
+          title: `Document: ${document.file_name || "Unknown Document"}`,
+          source: "Document",
+          description: `Document: ${document.file_name || "Unknown Document"}`,
+          text: `Document: ${document.file_name || "Unknown Document"}
+Size: ${document.file_size || 0} bytes
+Type: ${document.mime_type || "unknown"}`
+        });
+      }
+    }
+    if ("photo" in message && message.photo?.length > 0) {
+      const imageInfo = await this.processImage(message);
+      if (imageInfo) {
+        const photo = message.photo[message.photo.length - 1];
+        const fileLink = await this.bot.telegram.getFileLink(photo.file_id);
+        attachments.push({
+          id: photo.file_id,
+          url: fileLink.toString(),
+          title: "Image Attachment",
+          source: "Image",
+          description: imageInfo.description,
+          text: imageInfo.description
+        });
+      }
+    }
+    logger2.info(
+      `Message processed - Content: ${processedContent ? "yes" : "no"}, Attachments: ${attachments.length}`
+    );
+    return { processedContent, attachments };
+  }
   /**
    * Sends a message in chunks, handling attachments and splitting the message if necessary
    *
@@ -236,14 +485,14 @@ ${description}]` };
       const sentMessages = [];
       const telegramButtons = convertToTelegramButtons(content.buttons ?? []);
       if (!ctx.chat) {
-        logger.error("sendMessageInChunks: ctx.chat is undefined");
+        logger2.error("sendMessageInChunks: ctx.chat is undefined");
         return [];
       }
       await ctx.telegram.sendChatAction(ctx.chat.id, "typing");
       for (let i = 0; i < chunks.length; i++) {
         const chunk = convertMarkdownToTelegram(chunks[i]);
         if (!ctx.chat) {
-          logger.error("sendMessageInChunks loop: ctx.chat is undefined");
+          logger2.error("sendMessageInChunks loop: ctx.chat is undefined");
           continue;
         }
         const sentMessage = await ctx.telegram.sendMessage(ctx.chat.id, chunk, {
@@ -299,18 +548,18 @@ ${description}]` };
           fileStream.destroy();
         }
       }
-      logger.info(
+      logger2.info(
         `${type.charAt(0).toUpperCase() + type.slice(1)} sent successfully: ${mediaPath}`
       );
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
-      logger.error(`Failed to send ${type}. Path: ${mediaPath}. Error: ${errorMessage}`, {
-        originalError: error
-      });
+      logger2.error(
+        { originalError: error },
+        `Failed to send ${type}. Path: ${mediaPath}. Error: ${errorMessage}`
+      );
       throw error;
     }
   }
-  // Split message into smaller parts
   /**
    * Splits a given text into an array of strings based on the maximum message length.
    *
@@ -333,7 +582,6 @@ ${description}]` };
     if (currentChunk) chunks.push(currentChunk);
     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.
@@ -346,21 +594,23 @@ ${description}]` };
       const entityId = createUniqueUuid(this.runtime, ctx.from.id.toString());
       const threadId = "is_topic_message" in message && message.is_topic_message ? message.message_thread_id?.toString() : void 0;
       if (!ctx.chat) {
-        logger.error("handleMessage: ctx.chat is undefined");
+        logger2.error("handleMessage: ctx.chat is undefined");
         return;
       }
       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 = "";
-      if ("text" in message && message.text) {
-        messageText = message.text;
-      } else if ("caption" in message && message.caption) {
-        messageText = message.caption;
+      const { processedContent, attachments } = await this.processMessage(message);
+      const cleanedContent = cleanText(processedContent);
+      const cleanedAttachments = attachments.map((att) => ({
+        ...att,
+        text: cleanText(att.text),
+        description: cleanText(att.description),
+        title: cleanText(att.title)
+      }));
+      if (!cleanedContent && cleanedAttachments.length === 0) {
+        return;
       }
-      const fullText = imageInfo ? `${messageText} ${imageInfo.description}` : messageText;
-      if (!fullText) return;
       const chat = message.chat;
       const channelType = getChannelType(chat);
       const sourceId = createUniqueUuid(this.runtime, "" + chat.id);
@@ -382,10 +632,9 @@ ${description}]` };
         agentId: this.runtime.agentId,
         roomId,
         content: {
-          text: fullText,
-          // attachments?
+          text: cleanedContent || " ",
+          attachments: cleanedAttachments,
           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
         },
@@ -441,31 +690,27 @@ ${description}]` };
           }
           return memories;
         } catch (error) {
-          logger.error("Error in message callback:", error);
+          logger2.error({ error }, "Error in message callback");
           return [];
         }
       };
-      this.runtime.emitEvent(EventType.MESSAGE_RECEIVED, {
-        runtime: this.runtime,
-        message: memory,
-        callback,
-        source: "telegram"
-      });
-      this.runtime.emitEvent("TELEGRAM_MESSAGE_RECEIVED" /* MESSAGE_RECEIVED */, {
-        runtime: this.runtime,
-        message: memory,
-        callback,
-        source: "telegram",
-        ctx,
-        originalMessage: message
-      });
+      if (!this.runtime.messageService) {
+        logger2.error("Message service is not available");
+        throw new Error(
+          "Message service is not initialized. Ensure the message service is properly configured."
+        );
+      }
+      await this.runtime.messageService.handleMessage(this.runtime, memory, callback);
     } 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
-      });
+      logger2.error(
+        {
+          error,
+          chatId: ctx.chat?.id,
+          messageId: ctx.message?.message_id,
+          from: ctx.from?.username || ctx.from?.id
+        },
+        "Error handling Telegram message"
+      );
       throw error;
     }
   }
@@ -523,7 +768,7 @@ ${description}]` };
           };
           return [responseMemory];
         } catch (error) {
-          logger.error("Error in reaction callback:", error);
+          logger2.error({ error }, "Error in reaction callback");
           return [];
         }
       };
@@ -551,7 +796,13 @@ ${description}]` };
       });
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
-      logger.error("Error handling reaction:", { error: errorMessage, originalError: error });
+      logger2.error(
+        {
+          error: errorMessage,
+          originalError: error
+        },
+        "Error handling reaction"
+      );
     }
   }
   /**
@@ -611,10 +862,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
-      });
+      logger2.error(
+        {
+          error: errorMessage,
+          originalError: error
+        },
+        "Error sending message to Telegram"
+      );
       return [];
     }
   }
@@ -635,10 +889,10 @@ var TelegramService = class _TelegramService extends Service {
    */
   constructor(runtime) {
     super(runtime);
-    logger2.log("\u{1F4F1} Constructing new TelegramService...");
+    logger3.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");
+      logger3.warn("Telegram Bot Token not provided - Telegram functionality will be unavailable");
       this.bot = null;
       this.messageManager = null;
       return;
@@ -651,9 +905,11 @@ var TelegramService = class _TelegramService extends Service {
     try {
       this.bot = new Telegraf(botToken, this.options);
       this.messageManager = new MessageManager(this.bot, this.runtime);
-      logger2.log("\u2705 TelegramService constructor completed");
+      logger3.log("\u2705 TelegramService constructor completed");
     } catch (error) {
-      logger2.error(`Error initializing Telegram bot: ${error instanceof Error ? error.message : String(error)}`);
+      logger3.error(
+        `Error initializing Telegram bot: ${error instanceof Error ? error.message : String(error)}`
+      );
       this.bot = null;
       this.messageManager = null;
     }
@@ -667,7 +923,7 @@ var TelegramService = class _TelegramService extends Service {
   static async start(runtime) {
     const service = new _TelegramService(runtime);
     if (!service.bot) {
-      logger2.warn("Telegram service started without bot functionality - no bot token provided");
+      logger3.warn("Telegram service started without bot functionality - no bot token provided");
       return service;
     }
     const maxRetries = 5;
@@ -675,10 +931,10 @@ var TelegramService = class _TelegramService extends Service {
     let lastError = null;
     while (retryCount < maxRetries) {
       try {
-        logger2.success(
+        logger3.success(
           `\u2705 Telegram client successfully started for character ${runtime.character.name}`
         );
-        logger2.log("\u{1F680} Starting Telegram bot...");
+        logger3.log("\u{1F680} Starting Telegram bot...");
         await service.initializeBot();
         service.setupMiddlewares();
         service.setupMessageHandlers();
@@ -686,18 +942,18 @@ var TelegramService = class _TelegramService extends Service {
         return service;
       } catch (error) {
         lastError = error instanceof Error ? error : new Error(String(error));
-        logger2.error(
+        logger3.error(
           `Telegram initialization attempt ${retryCount + 1} failed: ${lastError.message}`
         );
         retryCount++;
         if (retryCount < maxRetries) {
           const delay = 2 ** retryCount * 1e3;
-          logger2.info(`Retrying Telegram initialization in ${delay / 1e3} seconds...`);
+          logger3.info(`Retrying Telegram initialization in ${delay / 1e3} seconds...`);
           await new Promise((resolve) => setTimeout(resolve, delay));
         }
       }
     }
-    logger2.error(
+    logger3.error(
       `Telegram initialization failed after ${maxRetries} attempts. Last error: ${lastError?.message}. Service will continue without Telegram functionality.`
     );
     return service;
@@ -736,7 +992,7 @@ var TelegramService = class _TelegramService extends Service {
       allowedUpdates: ["message", "message_reaction"]
     });
     const botInfo = await this.bot.telegram.getMe();
-    logger2.log(`Bot info: ${JSON.stringify(botInfo)}`);
+    logger3.log(`Bot info: ${JSON.stringify(botInfo)}`);
     process.once("SIGINT", () => this.bot?.stop("SIGINT"));
     process.once("SIGTERM", () => this.bot?.stop("SIGTERM"));
   }
@@ -770,7 +1026,7 @@ var TelegramService = class _TelegramService extends Service {
    */
   async authorizationMiddleware(ctx, next) {
     if (!await this.isGroupAuthorized(ctx)) {
-      logger2.debug("Chat not authorized, skipping message processing");
+      logger3.debug("Chat not authorized, skipping message processing");
       return;
     }
     await next();
@@ -810,7 +1066,7 @@ var TelegramService = class _TelegramService extends Service {
       try {
         await this.handleForumTopic(ctx);
       } catch (error) {
-        logger2.error(`Error handling forum topic: ${error}`);
+        logger3.error({ error }, `Error handling forum topic: ${error}`);
       }
     }
     if (ctx.from && ctx.chat.type !== "private") {
@@ -828,14 +1084,14 @@ var TelegramService = class _TelegramService extends Service {
       try {
         await this.messageManager.handleMessage(ctx);
       } catch (error) {
-        logger2.error("Error handling message:", error);
+        logger3.error({ error }, "Error handling message");
       }
     });
     this.bot?.on("message_reaction", async (ctx) => {
       try {
         await this.messageManager.handleReaction(ctx);
       } catch (error) {
-        logger2.error("Error handling reaction:", error);
+        logger3.error({ error }, "Error handling reaction");
       }
     });
   }
@@ -855,7 +1111,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);
+      logger3.error({ error }, "Error parsing TELEGRAM_ALLOWED_CHATS");
       return false;
     }
   }
@@ -1044,7 +1300,7 @@ var TelegramService = class _TelegramService extends Service {
         );
         owner = foundOwner || null;
       } catch (error) {
-        logger2.warn(
+        logger3.warn(
           `Could not get chat administrators: ${error instanceof Error ? error.message : String(error)}`
         );
       }
@@ -1157,13 +1413,13 @@ var TelegramService = class _TelegramService extends Service {
                 worldId
               });
             } else {
-              logger2.warn(
+              logger3.warn(
                 `Skipping entity sync due to missing ID: ${JSON.stringify(entity.names)}`
               );
             }
           } catch (err) {
             const telegramMetadata = entity.metadata?.telegram;
-            logger2.warn(`Failed to sync user ${telegramMetadata?.username}: ${err}`);
+            logger3.warn(`Failed to sync user ${telegramMetadata?.username}: ${err}`);
           }
         })
       );
@@ -1259,11 +1515,11 @@ var TelegramService = class _TelegramService extends Service {
             }
           }
         } catch (error) {
-          logger2.warn(`Could not fetch administrators for chat ${chat.id}: ${error}`);
+          logger3.warn(`Could not fetch administrators for chat ${chat.id}: ${error}`);
         }
       }
     } catch (error) {
-      logger2.error(
+      logger3.error(
         `Error building standardized entities: ${error instanceof Error ? error.message : String(error)}`
       );
     }
@@ -1315,7 +1571,7 @@ var TelegramService = class _TelegramService extends Service {
       };
       return room;
     } catch (error) {
-      logger2.error(
+      logger3.error(
         `Error building forum topic room: ${error instanceof Error ? error.message : String(error)}`
       );
       return null;
@@ -1327,14 +1583,14 @@ var TelegramService = class _TelegramService extends Service {
         "telegram",
         serviceInstance.handleSendMessage.bind(serviceInstance)
       );
-      logger2.info("[Telegram] Registered send handler.");
+      logger3.info("[Telegram] Registered send handler.");
     } else {
-      logger2.warn("[Telegram] Cannot register send handler - bot not initialized.");
+      logger3.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.");
+      logger3.error("[Telegram SendHandler] Bot not initialized - cannot send messages.");
       throw new Error("Telegram bot is not initialized. Please provide TELEGRAM_BOT_TOKEN.");
     }
     let chatId;
@@ -1346,7 +1602,7 @@ var TelegramService = class _TelegramService extends Service {
       if (!chatId)
         throw new Error(`Could not resolve Telegram chat ID from roomId ${target.roomId}`);
     } else if (target.entityId) {
-      logger2.error("[Telegram SendHandler] Sending DMs via entityId not implemented yet.");
+      logger3.error("[Telegram SendHandler] Sending DMs via entityId not implemented yet.");
       throw new Error("Sending DMs via entityId is not yet supported for Telegram.");
     } else {
       throw new Error("Telegram SendHandler requires channelId, roomId, or entityId.");
@@ -1358,14 +1614,14 @@ var TelegramService = class _TelegramService extends Service {
     }
     try {
       await this.messageManager.sendMessage(chatId, content);
-      logger2.info(`[Telegram SendHandler] Message sent to chat ID: ${chatId}`);
+      logger3.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)}`,
+      logger3.error(
         {
           target,
           content
-        }
+        },
+        `[Telegram SendHandler] Error sending message: ${error instanceof Error ? error.message : String(error)}`
       );
       throw error;
     }
@@ -1373,7 +1629,7 @@ var TelegramService = class _TelegramService extends Service {
 };
 
 // src/tests.ts
-import { logger as logger3 } from "@elizaos/core";
+import { logger as logger4 } from "@elizaos/core";
 var TEST_IMAGE_URL = "https://github.com/elizaOS/awesome-eliza/blob/main/assets/eliza-logo.jpg?raw=true";
 var TelegramTestSuite = class {
   name = "telegram";
@@ -1442,7 +1698,7 @@ var TelegramTestSuite = class {
         throw new Error("Bot is not initialized.");
       }
       const chat = await this.bot.telegram.getChat(chatId);
-      logger3.log(`Fetched real chat: ${JSON.stringify(chat)}`);
+      logger4.log(`Fetched real chat: ${JSON.stringify(chat)}`);
       return chat;
     } catch (error) {
       throw new Error(`Error fetching real Telegram chat: ${error}`);
@@ -1451,18 +1707,20 @@ 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");
+      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.");
+    logger4.debug("Telegram bot initialized successfully.");
   }
   async testSendingTextMessage(runtime) {
     try {
       if (!this.bot) throw new Error("Bot not initialized.");
       const chatId = this.validateChatId(runtime);
       await this.bot.telegram.sendMessage(chatId, "Testing Telegram message!");
-      logger3.debug("Message sent successfully.");
+      logger4.debug("Message sent successfully.");
     } catch (error) {
       throw new Error(`Error sending Telegram message: ${error}`);
     }
@@ -1491,8 +1749,11 @@ var TelegramTestSuite = class {
           }
         ]
       };
-      await this.messageManager.sendMessageInChunks(mockContext, messageContent);
-      logger3.success("Message with image attachment sent successfully.");
+      await this.messageManager.sendMessageInChunks(
+        mockContext,
+        messageContent
+      );
+      logger4.success("Message with image attachment sent successfully.");
     } catch (error) {
       throw new Error(`Error sending Telegram message with attachment: ${error}`);
     }
@@ -1553,7 +1814,7 @@ var TelegramTestSuite = class {
         throw new Error("Error processing Telegram image or description not found");
       }
       const { description } = result;
-      logger3.log(`Processing Telegram image successfully: ${description}`);
+      logger4.log(`Processing Telegram image successfully: ${description}`);
     } catch (error) {
       throw new Error(`Error processing Telegram image: ${error}`);
     }
@@ -1569,7 +1830,7 @@ var TelegramTestSuite = class {
       }
       return message.photo[message.photo.length - 1].file_id;
     } catch (error) {
-      logger3.error(`Error sending image: ${error}`);
+      logger4.error({ error }, `Error sending image: ${error}`);
       throw error;
     }
   }