@elizaos/plugin-telegram 1.0.10 → 1.6.3

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,14 +129,32 @@ 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({ src: "plugin:telegram", buttonKind: button.kind }, "Unknown 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
@@ -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.debug({ src: "plugin:telegram", agentId: this.runtime.agentId, messageId: message.message_id }, "Processing image from message");
       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();
       }
@@ -193,11 +212,237 @@ var MessageManager = class {
 ${description}]` };
       }
     } catch (error) {
-      console.error("\u274C Error processing image:", error);
+      logger2.error({ src: "plugin:telegram", agentId: this.runtime.agentId, error: error instanceof Error ? error.message : String(error) }, "Error processing image");
+    }
+    return null;
+  }
+  /**
+   * 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.debug({ src: "plugin:telegram", agentId: this.runtime.agentId, fileName: document.file_name, mimeType: document.mime_type, fileSize: document.file_size }, "Processing document");
+      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({ src: "plugin:telegram", agentId: this.runtime.agentId, error: error instanceof Error ? error.message : String(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;
   }
-  // Send long messages in chunks
+  /**
+   * Process PDF documents by converting them to text.
+   */
+  async processPdfDocument(document, documentUrl) {
+    try {
+      const pdfService = this.runtime.getService(ServiceType.PDF);
+      if (!pdfService) {
+        logger2.warn({ src: "plugin:telegram", agentId: this.runtime.agentId }, "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.debug({ src: "plugin:telegram", agentId: this.runtime.agentId, fileName: document.file_name, charactersExtracted: text.length }, "PDF processed successfully");
+      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({ src: "plugin:telegram", agentId: this.runtime.agentId, fileName: document.file_name, error: error instanceof Error ? error.message : String(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.debug({ src: "plugin:telegram", agentId: this.runtime.agentId, fileName: document.file_name, charactersExtracted: text.length }, "Text document processed successfully");
+      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({ src: "plugin:telegram", agentId: this.runtime.agentId, fileName: document.file_name, error: error instanceof Error ? error.message : String(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.debug({ src: "plugin:telegram", agentId: this.runtime.agentId, fileName: documentInfo.fileName }, "Document processed successfully");
+        } catch (error) {
+          logger2.error({ src: "plugin:telegram", agentId: this.runtime.agentId, fileName: documentInfo.fileName, error: error instanceof Error ? error.message : String(error) }, "Error processing document");
+          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.debug({ src: "plugin:telegram", agentId: this.runtime.agentId, hasContent: !!processedContent, attachmentsCount: attachments.length }, "Message processed");
+    return { processedContent, attachments };
+  }
   /**
    * Sends a message in chunks, handling attachments and splitting the message if necessary
    *
@@ -236,14 +481,14 @@ ${description}]` };
       const sentMessages = [];
       const telegramButtons = convertToTelegramButtons(content.buttons ?? []);
       if (!ctx.chat) {
-        logger.error("sendMessageInChunks: ctx.chat is undefined");
+        logger2.error({ src: "plugin:telegram", agentId: this.runtime.agentId }, "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({ src: "plugin:telegram", agentId: this.runtime.agentId }, "sendMessageInChunks loop: ctx.chat is undefined");
           continue;
         }
         const sentMessage = await ctx.telegram.sendMessage(ctx.chat.id, chunk, {
@@ -299,19 +544,12 @@ ${description}]` };
           fileStream.destroy();
         }
       }
-      logger.info(
-        `${type.charAt(0).toUpperCase() + type.slice(1)} sent successfully: ${mediaPath}`
-      );
+      logger2.debug({ src: "plugin:telegram", agentId: this.runtime.agentId, mediaType: type, mediaPath }, "Media sent successfully");
     } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      logger.error(
-        { originalError: error },
-        `Failed to send ${type}. Path: ${mediaPath}. Error: ${errorMessage}`
-      );
+      logger2.error({ src: "plugin:telegram", agentId: this.runtime.agentId, mediaType: type, mediaPath, error: error instanceof Error ? error.message : String(error) }, "Failed to send media");
       throw error;
     }
   }
-  // Split message into smaller parts
   /**
    * Splits a given text into an array of strings based on the maximum message length.
    *
@@ -334,7 +572,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.
@@ -347,21 +584,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({ src: "plugin:telegram", agentId: this.runtime.agentId }, "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);
@@ -383,10 +622,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
         },
@@ -442,34 +680,19 @@ ${description}]` };
           }
           return memories;
         } catch (error) {
-          logger.error({ error }, "Error in message callback");
+          logger2.error({ src: "plugin:telegram", agentId: this.runtime.agentId, error: error instanceof Error ? error.message : String(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({ src: "plugin:telegram", agentId: this.runtime.agentId }, "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,
-          chatId: ctx.chat?.id,
-          messageId: ctx.message?.message_id,
-          from: ctx.from?.username || ctx.from?.id
-        },
-        "Error handling Telegram message"
-      );
+      logger2.error({ src: "plugin:telegram", agentId: this.runtime.agentId, chatId: ctx.chat?.id, messageId: ctx.message?.message_id, from: ctx.from?.username || ctx.from?.id, error: error instanceof Error ? error.message : String(error) }, "Error handling Telegram message");
       throw error;
     }
   }
@@ -527,7 +750,7 @@ ${description}]` };
           };
           return [responseMemory];
         } catch (error) {
-          logger.error({ error }, "Error in reaction callback");
+          logger2.error({ src: "plugin:telegram", agentId: this.runtime.agentId, error: error instanceof Error ? error.message : String(error) }, "Error in reaction callback");
           return [];
         }
       };
@@ -554,14 +777,7 @@ ${description}]` };
         originalReaction: reaction.new_reaction[0]
       });
     } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      logger.error(
-        {
-          error: errorMessage,
-          originalError: error
-        },
-        "Error handling reaction"
-      );
+      logger2.error({ src: "plugin:telegram", agentId: this.runtime.agentId, error: error instanceof Error ? error.message : String(error) }, "Error handling reaction");
     }
   }
   /**
@@ -620,14 +836,7 @@ ${description}]` };
       });
       return sentMessages;
     } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      logger.error(
-        {
-          error: errorMessage,
-          originalError: error
-        },
-        "Error sending message to Telegram"
-      );
+      logger2.error({ src: "plugin:telegram", agentId: this.runtime.agentId, chatId, error: error instanceof Error ? error.message : String(error) }, "Error sending message to Telegram");
       return [];
     }
   }
@@ -648,10 +857,10 @@ var TelegramService = class _TelegramService extends Service {
    */
   constructor(runtime) {
     super(runtime);
-    logger2.log("\u{1F4F1} Constructing new TelegramService...");
+    logger3.debug({ src: "plugin:telegram", agentId: runtime.agentId }, "Constructing 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({ src: "plugin:telegram", agentId: runtime.agentId }, "Bot token not provided, Telegram functionality unavailable");
       this.bot = null;
       this.messageManager = null;
       return;
@@ -664,11 +873,9 @@ 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.debug({ src: "plugin:telegram", agentId: runtime.agentId }, "TelegramService constructor completed");
     } catch (error) {
-      logger2.error(
-        `Error initializing Telegram bot: ${error instanceof Error ? error.message : String(error)}`
-      );
+      logger3.error({ src: "plugin:telegram", agentId: runtime.agentId, error: error instanceof Error ? error.message : String(error) }, "Failed to initialize Telegram bot");
       this.bot = null;
       this.messageManager = null;
     }
@@ -682,7 +889,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({ src: "plugin:telegram", agentId: runtime.agentId }, "Service started without bot functionality");
       return service;
     }
     const maxRetries = 5;
@@ -690,31 +897,25 @@ var TelegramService = class _TelegramService extends Service {
     let lastError = null;
     while (retryCount < maxRetries) {
       try {
-        logger2.success(
-          `\u2705 Telegram client successfully started for character ${runtime.character.name}`
-        );
-        logger2.log("\u{1F680} Starting Telegram bot...");
+        logger3.info({ src: "plugin:telegram", agentId: runtime.agentId, agentName: runtime.character.name }, "Starting Telegram bot");
         await service.initializeBot();
         service.setupMiddlewares();
         service.setupMessageHandlers();
         await service.bot.telegram.getMe();
+        logger3.success({ src: "plugin:telegram", agentId: runtime.agentId, agentName: runtime.character.name }, "Telegram bot started successfully");
         return service;
       } catch (error) {
         lastError = error instanceof Error ? error : new Error(String(error));
-        logger2.error(
-          `Telegram initialization attempt ${retryCount + 1} failed: ${lastError.message}`
-        );
+        logger3.error({ src: "plugin:telegram", agentId: runtime.agentId, attempt: retryCount + 1, error: lastError.message }, "Initialization attempt failed");
         retryCount++;
         if (retryCount < maxRetries) {
           const delay = 2 ** retryCount * 1e3;
-          logger2.info(`Retrying Telegram initialization in ${delay / 1e3} seconds...`);
+          logger3.info({ src: "plugin:telegram", agentId: runtime.agentId, delaySeconds: delay / 1e3 }, "Retrying initialization");
           await new Promise((resolve) => setTimeout(resolve, delay));
         }
       }
     }
-    logger2.error(
-      `Telegram initialization failed after ${maxRetries} attempts. Last error: ${lastError?.message}. Service will continue without Telegram functionality.`
-    );
+    logger3.error({ src: "plugin:telegram", agentId: runtime.agentId, maxRetries, error: lastError?.message }, "Initialization failed after all attempts");
     return service;
   }
   /**
@@ -751,7 +952,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.debug({ src: "plugin:telegram", agentId: this.runtime.agentId, botId: botInfo.id, botUsername: botInfo.username }, "Bot info retrieved");
     process.once("SIGINT", () => this.bot?.stop("SIGINT"));
     process.once("SIGTERM", () => this.bot?.stop("SIGTERM"));
   }
@@ -785,7 +986,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({ src: "plugin:telegram", agentId: this.runtime.agentId, chatId: ctx.chat?.id }, "Chat not authorized, skipping");
       return;
     }
     await next();
@@ -825,7 +1026,7 @@ var TelegramService = class _TelegramService extends Service {
       try {
         await this.handleForumTopic(ctx);
       } catch (error) {
-        logger2.error({ error }, `Error handling forum topic: ${error}`);
+        logger3.error({ src: "plugin:telegram", agentId: this.runtime.agentId, chatId: chat.id, error: error instanceof Error ? error.message : String(error) }, "Error handling forum topic");
       }
     }
     if (ctx.from && ctx.chat.type !== "private") {
@@ -843,14 +1044,14 @@ var TelegramService = class _TelegramService extends Service {
       try {
         await this.messageManager.handleMessage(ctx);
       } catch (error) {
-        logger2.error({ error }, "Error handling message");
+        logger3.error({ src: "plugin:telegram", agentId: this.runtime.agentId, error: error instanceof Error ? error.message : String(error) }, "Error handling message");
       }
     });
     this.bot?.on("message_reaction", async (ctx) => {
       try {
         await this.messageManager.handleReaction(ctx);
       } catch (error) {
-        logger2.error({ error }, "Error handling reaction");
+        logger3.error({ src: "plugin:telegram", agentId: this.runtime.agentId, error: error instanceof Error ? error.message : String(error) }, "Error handling reaction");
       }
     });
   }
@@ -870,7 +1071,7 @@ var TelegramService = class _TelegramService extends Service {
       const allowedChatsList = JSON.parse(allowedChats);
       return allowedChatsList.includes(chatId);
     } catch (error) {
-      logger2.error({ error }, "Error parsing TELEGRAM_ALLOWED_CHATS");
+      logger3.error({ src: "plugin:telegram", agentId: this.runtime.agentId, error: error instanceof Error ? error.message : String(error) }, "Error parsing TELEGRAM_ALLOWED_CHATS");
       return false;
     }
   }
@@ -1059,9 +1260,7 @@ var TelegramService = class _TelegramService extends Service {
         );
         owner = foundOwner || null;
       } catch (error) {
-        logger2.warn(
-          `Could not get chat administrators: ${error instanceof Error ? error.message : String(error)}`
-        );
+        logger3.warn({ src: "plugin:telegram", agentId: this.runtime.agentId, chatId, error: error instanceof Error ? error.message : String(error) }, "Could not get chat administrators");
       }
     }
     let ownerId = userId;
@@ -1172,13 +1371,11 @@ var TelegramService = class _TelegramService extends Service {
                 worldId
               });
             } else {
-              logger2.warn(
-                `Skipping entity sync due to missing ID: ${JSON.stringify(entity.names)}`
-              );
+              logger3.warn({ src: "plugin:telegram", agentId: this.runtime.agentId, entityNames: entity.names }, "Skipping entity sync due to missing ID");
             }
           } catch (err) {
             const telegramMetadata = entity.metadata?.telegram;
-            logger2.warn(`Failed to sync user ${telegramMetadata?.username}: ${err}`);
+            logger3.warn({ src: "plugin:telegram", agentId: this.runtime.agentId, username: telegramMetadata?.username, error: err instanceof Error ? err.message : String(err) }, "Failed to sync user");
           }
         })
       );
@@ -1274,13 +1471,11 @@ var TelegramService = class _TelegramService extends Service {
             }
           }
         } catch (error) {
-          logger2.warn(`Could not fetch administrators for chat ${chat.id}: ${error}`);
+          logger3.warn({ src: "plugin:telegram", agentId: this.runtime.agentId, chatId: chat.id, error: error instanceof Error ? error.message : String(error) }, "Could not fetch administrators");
         }
       }
     } catch (error) {
-      logger2.error(
-        `Error building standardized entities: ${error instanceof Error ? error.message : String(error)}`
-      );
+      logger3.error({ src: "plugin:telegram", agentId: this.runtime.agentId, error: error instanceof Error ? error.message : String(error) }, "Error building standardized entities");
     }
     return entities;
   }
@@ -1330,9 +1525,7 @@ var TelegramService = class _TelegramService extends Service {
       };
       return room;
     } catch (error) {
-      logger2.error(
-        `Error building forum topic room: ${error instanceof Error ? error.message : String(error)}`
-      );
+      logger3.error({ src: "plugin:telegram", agentId: this.runtime.agentId, chatId, threadId, error: error instanceof Error ? error.message : String(error) }, "Error building forum topic room");
       return null;
     }
   }
@@ -1342,14 +1535,14 @@ var TelegramService = class _TelegramService extends Service {
         "telegram",
         serviceInstance.handleSendMessage.bind(serviceInstance)
       );
-      logger2.info("[Telegram] Registered send handler.");
+      logger3.info({ src: "plugin:telegram", agentId: runtime.agentId }, "Registered send handler");
     } else {
-      logger2.warn("[Telegram] Cannot register send handler - bot not initialized.");
+      logger3.warn({ src: "plugin:telegram", agentId: runtime.agentId }, "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({ src: "plugin:telegram", agentId: runtime.agentId }, "Bot not initialized, cannot send messages");
       throw new Error("Telegram bot is not initialized. Please provide TELEGRAM_BOT_TOKEN.");
     }
     let chatId;
@@ -1361,7 +1554,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({ src: "plugin:telegram", agentId: runtime.agentId, entityId: target.entityId }, "Sending DMs via entityId not implemented");
       throw new Error("Sending DMs via entityId is not yet supported for Telegram.");
     } else {
       throw new Error("Telegram SendHandler requires channelId, roomId, or entityId.");
@@ -1373,22 +1566,16 @@ 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({ src: "plugin:telegram", agentId: runtime.agentId, chatId }, "Message sent");
     } catch (error) {
-      logger2.error(
-        {
-          target,
-          content
-        },
-        `[Telegram SendHandler] Error sending message: ${error instanceof Error ? error.message : String(error)}`
-      );
+      logger3.error({ src: "plugin:telegram", agentId: runtime.agentId, chatId, error: error instanceof Error ? error.message : String(error) }, "Error sending message");
       throw error;
     }
   }
 };
 
 // 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";
@@ -1457,7 +1644,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.debug({ src: "plugin:telegram", chatId }, "Fetched real chat");
       return chat;
     } catch (error) {
       throw new Error(`Error fetching real Telegram chat: ${error}`);
@@ -1472,14 +1659,14 @@ var TelegramTestSuite = class {
     }
     this.bot = this.telegramClient.messageManager.bot;
     this.messageManager = this.telegramClient.messageManager;
-    logger3.debug("Telegram bot initialized successfully.");
+    logger4.debug({ src: "plugin:telegram" }, "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({ src: "plugin:telegram", chatId }, "Message sent successfully");
     } catch (error) {
       throw new Error(`Error sending Telegram message: ${error}`);
     }
@@ -1512,7 +1699,7 @@ var TelegramTestSuite = class {
         mockContext,
         messageContent
       );
-      logger3.success("Message with image attachment sent successfully.");
+      logger4.success({ src: "plugin:telegram" }, "Message with image attachment sent successfully");
     } catch (error) {
       throw new Error(`Error sending Telegram message with attachment: ${error}`);
     }
@@ -1573,7 +1760,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.debug({ src: "plugin:telegram", description }, "Processing Telegram image successfully");
     } catch (error) {
       throw new Error(`Error processing Telegram image: ${error}`);
     }
@@ -1589,7 +1776,7 @@ var TelegramTestSuite = class {
       }
       return message.photo[message.photo.length - 1].file_id;
     } catch (error) {
-      logger3.error({ error }, `Error sending image: ${error}`);
+      logger4.error({ src: "plugin:telegram", chatId, error: error instanceof Error ? error.message : String(error) }, "Error sending image");
       throw error;
     }
   }