@elizaos/plugin-telegram 1.6.2 → 1.6.4

package/dist/environment.d.ts

@@ -1,4 +1,4 @@
-import type { IAgentRuntime } from '@elizaos/core';
+import { type IAgentRuntime } from '@elizaos/core';
 import { z } from 'zod';
 export declare const telegramEnvSchema: z.ZodObject<{
     TELEGRAM_BOT_TOKEN: z.ZodString;

package/dist/index.js

@@ -144,7 +144,7 @@ function convertToTelegramButtons(buttons) {
         telegramButton = Markup.button.url(button.text, button.url);
         break;
       default:
-        logger.warn(`Unknown button kind '${button.kind}', treating as URL button`);
+        logger.warn({ src: "plugin:telegram", buttonKind: button.kind }, "Unknown button kind, treating as URL button");
         telegramButton = Markup.button.url(button.text, button.url);
         break;
     }
@@ -194,7 +194,7 @@ var MessageManager = class {
   async processImage(message) {
     try {
       let imageUrl = null;
-      logger2.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);
@@ -212,7 +212,7 @@ 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;
   }
@@ -231,9 +231,7 @@ ${description}]` };
       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)`
-      );
+      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);
@@ -249,7 +247,7 @@ Size: ${document.file_size || 0} bytes]`,
         fileSize: document.file_size
       };
     } catch (error) {
-      logger2.error({ error }, "Error processing document");
+      logger2.error({ src: "plugin:telegram", agentId: this.runtime.agentId, error: error instanceof Error ? error.message : String(error) }, "Error processing document");
       return null;
     }
   }
@@ -278,7 +276,7 @@ Size: ${document.file_size || 0} bytes]`,
     try {
       const pdfService = this.runtime.getService(ServiceType.PDF);
       if (!pdfService) {
-        logger2.warn("PDF service not available, using fallback");
+        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: "",
@@ -296,7 +294,7 @@ Unable to extract text content]`,
       }
       const pdfBuffer = await response.arrayBuffer();
       const text = await pdfService.convertPdfToText(Buffer.from(pdfBuffer));
-      logger2.info(`PDF processed successfully: ${text.length} characters extracted`);
+      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,
@@ -308,7 +306,7 @@ Text extracted successfully: ${text.length} characters]`,
         fileSize: document.file_size
       };
     } catch (error) {
-      logger2.error({ error }, "Error processing PDF document");
+      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: "",
@@ -331,7 +329,7 @@ Error: Unable to extract text content]`,
         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`);
+      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,
@@ -343,7 +341,7 @@ Text extracted successfully: ${text.length} characters]`,
         fileSize: document.file_size
       };
     } catch (error) {
-      logger2.error({ error }, "Error processing text document");
+      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: "",
@@ -400,9 +398,9 @@ ${fullText}
             description: documentInfo.formattedDescription,
             text: fullText
           });
-          logger2.info(`Document processed successfully: ${documentInfo.fileName}`);
+          logger2.debug({ src: "plugin:telegram", agentId: this.runtime.agentId, fileName: documentInfo.fileName }, "Document processed successfully");
         } catch (error) {
-          logger2.error({ error }, `Error processing document ${documentInfo.fileName}`);
+          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: "",
@@ -442,9 +440,7 @@ Type: ${document.mime_type || "unknown"}`
         });
       }
     }
-    logger2.info(
-      `Message processed - Content: ${processedContent ? "yes" : "no"}, Attachments: ${attachments.length}`
-    );
+    logger2.debug({ src: "plugin:telegram", agentId: this.runtime.agentId, hasContent: !!processedContent, attachmentsCount: attachments.length }, "Message processed");
     return { processedContent, attachments };
   }
   /**
@@ -485,14 +481,14 @@ Type: ${document.mime_type || "unknown"}`
       const sentMessages = [];
       const telegramButtons = convertToTelegramButtons(content.buttons ?? []);
       if (!ctx.chat) {
-        logger2.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) {
-          logger2.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, {
@@ -548,15 +544,9 @@ Type: ${document.mime_type || "unknown"}`
           fileStream.destroy();
         }
       }
-      logger2.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);
-      logger2.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;
     }
   }
@@ -594,7 +584,7 @@ Type: ${document.mime_type || "unknown"}`
       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) {
-        logger2.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();
@@ -621,7 +611,6 @@ Type: ${document.mime_type || "unknown"}`
         name: ctx.from.first_name,
         source: "telegram",
         channelId: telegramRoomid,
-        serverId: void 0,
         type: channelType,
         worldId: createUniqueUuid(this.runtime, roomId),
         worldName: telegramRoomid
@@ -690,27 +679,26 @@ Type: ${document.mime_type || "unknown"}`
           }
           return memories;
         } catch (error) {
-          logger2.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 [];
         }
       };
-      if (!this.runtime.messageService) {
-        logger2.error("Message service is not available");
+      if (this.runtime.hasElizaOS()) {
+        await this.runtime.elizaOS.handleMessage(this.runtime.agentId, memory, {
+          onResponse: async (content) => {
+            await callback(content);
+          }
+        });
+      } else if (this.runtime.messageService) {
+        await this.runtime.messageService.handleMessage(this.runtime, memory, callback);
+      } else {
+        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) {
-      logger2.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;
     }
   }
@@ -768,7 +756,7 @@ Type: ${document.mime_type || "unknown"}`
           };
           return [responseMemory];
         } catch (error) {
-          logger2.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 [];
         }
       };
@@ -795,14 +783,7 @@ Type: ${document.mime_type || "unknown"}`
         originalReaction: reaction.new_reaction[0]
       });
     } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      logger2.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");
     }
   }
   /**
@@ -847,28 +828,26 @@ Type: ${document.mime_type || "unknown"}`
         await this.runtime.createMemory(memory, "messages");
         memories.push(memory);
       }
-      this.runtime.emitEvent(EventType.MESSAGE_SENT, {
-        runtime: this.runtime,
-        message: {
-          content
-        },
-        roomId,
-        source: "telegram"
-      });
-      this.runtime.emitEvent("TELEGRAM_MESSAGE_SENT" /* MESSAGE_SENT */, {
-        originalMessages: sentMessages,
-        chatId
-      });
-      return sentMessages;
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      logger2.error(
+      if (memories.length > 0) {
+        this.runtime.emitEvent(EventType.MESSAGE_SENT, {
+          runtime: this.runtime,
+          message: memories[0],
+          source: "telegram"
+        });
+      }
+      this.runtime.emitEvent(
+        "TELEGRAM_MESSAGE_SENT" /* MESSAGE_SENT */,
         {
-          error: errorMessage,
-          originalError: error
-        },
-        "Error sending message to Telegram"
+          runtime: this.runtime,
+          source: "telegram",
+          originalMessages: sentMessages,
+          chatId,
+          message: memories[0]
+        }
       );
+      return sentMessages;
+    } catch (error) {
+      logger2.error({ src: "plugin:telegram", agentId: this.runtime.agentId, chatId, error: error instanceof Error ? error.message : String(error) }, "Error sending message to Telegram");
       return [];
     }
   }
@@ -889,10 +868,10 @@ var TelegramService = class _TelegramService extends Service {
    */
   constructor(runtime) {
     super(runtime);
-    logger3.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() === "") {
-      logger3.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;
@@ -905,11 +884,9 @@ var TelegramService = class _TelegramService extends Service {
     try {
       this.bot = new Telegraf(botToken, this.options);
       this.messageManager = new MessageManager(this.bot, this.runtime);
-      logger3.log("\u2705 TelegramService constructor completed");
+      logger3.debug({ src: "plugin:telegram", agentId: runtime.agentId }, "TelegramService constructor completed");
     } catch (error) {
-      logger3.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;
     }
@@ -923,7 +900,7 @@ var TelegramService = class _TelegramService extends Service {
   static async start(runtime) {
     const service = new _TelegramService(runtime);
     if (!service.bot) {
-      logger3.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;
@@ -931,31 +908,25 @@ var TelegramService = class _TelegramService extends Service {
     let lastError = null;
     while (retryCount < maxRetries) {
       try {
-        logger3.success(
-          `\u2705 Telegram client successfully started for character ${runtime.character.name}`
-        );
-        logger3.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));
-        logger3.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;
-          logger3.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));
         }
       }
     }
-    logger3.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;
   }
   /**
@@ -982,17 +953,21 @@ var TelegramService = class _TelegramService extends Service {
    */
   async initializeBot() {
     this.bot?.start((ctx) => {
-      this.runtime.emitEvent(["TELEGRAM_SLASH_START" /* SLASH_START */], {
-        // we don't need this
-        ctx
-      });
+      this.runtime.emitEvent(
+        "TELEGRAM_SLASH_START" /* SLASH_START */,
+        {
+          ctx,
+          runtime: this.runtime,
+          source: "telegram"
+        }
+      );
     });
     this.bot?.launch({
       dropPendingUpdates: true,
       allowedUpdates: ["message", "message_reaction"]
     });
     const botInfo = await this.bot.telegram.getMe();
-    logger3.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"));
   }
@@ -1026,7 +1001,7 @@ var TelegramService = class _TelegramService extends Service {
    */
   async authorizationMiddleware(ctx, next) {
     if (!await this.isGroupAuthorized(ctx)) {
-      logger3.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();
@@ -1066,7 +1041,7 @@ var TelegramService = class _TelegramService extends Service {
       try {
         await this.handleForumTopic(ctx);
       } catch (error) {
-        logger3.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") {
@@ -1084,14 +1059,14 @@ var TelegramService = class _TelegramService extends Service {
       try {
         await this.messageManager.handleMessage(ctx);
       } catch (error) {
-        logger3.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) {
-        logger3.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");
       }
     });
   }
@@ -1111,7 +1086,7 @@ var TelegramService = class _TelegramService extends Service {
       const allowedChatsList = JSON.parse(allowedChats);
       return allowedChatsList.includes(chatId);
     } catch (error) {
-      logger3.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;
     }
   }
@@ -1162,7 +1137,6 @@ var TelegramService = class _TelegramService extends Service {
         name: ctx.from.first_name || ctx.from.username || "Unknown User",
         source: "telegram",
         channelId: chatId,
-        serverId: chatId,
         type: ChannelType2.GROUP,
         worldId
       });
@@ -1194,18 +1168,24 @@ var TelegramService = class _TelegramService extends Service {
         name: newMember.first_name || newMember.username || "Unknown User",
         source: "telegram",
         channelId: chatId,
-        serverId: chatId,
         type: ChannelType2.GROUP,
         worldId
       });
       this.syncedEntityIds.add(entityId);
-      this.runtime.emitEvent(["TELEGRAM_ENTITY_JOINED" /* ENTITY_JOINED */], {
-        runtime: this.runtime,
-        entityId,
-        worldId,
-        newMember,
-        ctx
-      });
+      this.runtime.emitEvent(
+        "TELEGRAM_ENTITY_JOINED" /* ENTITY_JOINED */,
+        {
+          runtime: this.runtime,
+          entityId,
+          worldId,
+          source: "telegram",
+          telegramUser: {
+            id: newMember.id,
+            username: newMember.username,
+            first_name: newMember.first_name
+          }
+        }
+      );
     }
   }
   /**
@@ -1300,9 +1280,7 @@ var TelegramService = class _TelegramService extends Service {
         );
         owner = foundOwner || null;
       } catch (error) {
-        logger3.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;
@@ -1355,7 +1333,6 @@ var TelegramService = class _TelegramService extends Service {
       entities,
       generalRoom.id,
       generalRoom.channelId,
-      generalRoom.serverId,
       generalRoom.type,
       worldId
     );
@@ -1385,13 +1362,12 @@ var TelegramService = class _TelegramService extends Service {
    * @param {Entity[]} entities - The entities to process
    * @param {UUID} roomId - The ID of the room to connect entities to
    * @param {string} channelId - The channel ID
-   * @param {string} serverId - The server ID
    * @param {ChannelType} roomType - The type of the room
    * @param {UUID} worldId - The ID of the world
    * @returns {Promise<void>}
    * @private
    */
-  async batchProcessEntities(entities, roomId, channelId, serverId, roomType, worldId) {
+  async batchProcessEntities(entities, roomId, channelId, roomType, worldId) {
     const batchSize = 50;
     for (let i = 0; i < entities.length; i += batchSize) {
       const entityBatch = entities.slice(i, i + batchSize);
@@ -1408,18 +1384,15 @@ var TelegramService = class _TelegramService extends Service {
                 userId: telegramMetadata?.id,
                 source: "telegram",
                 channelId,
-                serverId,
                 type: roomType,
                 worldId
               });
             } else {
-              logger3.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;
-            logger3.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");
           }
         })
       );
@@ -1515,13 +1488,11 @@ var TelegramService = class _TelegramService extends Service {
             }
           }
         } catch (error) {
-          logger3.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) {
-      logger3.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;
   }
@@ -1571,9 +1542,7 @@ var TelegramService = class _TelegramService extends Service {
       };
       return room;
     } catch (error) {
-      logger3.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;
     }
   }
@@ -1583,14 +1552,14 @@ var TelegramService = class _TelegramService extends Service {
         "telegram",
         serviceInstance.handleSendMessage.bind(serviceInstance)
       );
-      logger3.info("[Telegram] Registered send handler.");
+      logger3.info({ src: "plugin:telegram", agentId: runtime.agentId }, "Registered send handler");
     } else {
-      logger3.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) {
-      logger3.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;
@@ -1602,7 +1571,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) {
-      logger3.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.");
@@ -1614,15 +1583,9 @@ var TelegramService = class _TelegramService extends Service {
     }
     try {
       await this.messageManager.sendMessage(chatId, content);
-      logger3.info(`[Telegram SendHandler] Message sent to chat ID: ${chatId}`);
+      logger3.info({ src: "plugin:telegram", agentId: runtime.agentId, chatId }, "Message sent");
     } catch (error) {
-      logger3.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;
     }
   }
@@ -1684,7 +1647,7 @@ var TelegramTestSuite = class {
    */
   validateChatId(runtime) {
     const testChatId = runtime.getSetting("TELEGRAM_TEST_CHAT_ID") || process.env.TELEGRAM_TEST_CHAT_ID;
-    if (!testChatId) {
+    if (!testChatId || typeof testChatId === "boolean") {
       throw new Error(
         "TELEGRAM_TEST_CHAT_ID is not set. Please provide a valid chat ID in the environment variables."
       );
@@ -1698,7 +1661,7 @@ var TelegramTestSuite = class {
         throw new Error("Bot is not initialized.");
       }
       const chat = await this.bot.telegram.getChat(chatId);
-      logger4.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}`);
@@ -1713,14 +1676,14 @@ var TelegramTestSuite = class {
     }
     this.bot = this.telegramClient.messageManager.bot;
     this.messageManager = this.telegramClient.messageManager;
-    logger4.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!");
-      logger4.debug("Message sent successfully.");
+      logger4.debug({ src: "plugin:telegram", chatId }, "Message sent successfully");
     } catch (error) {
       throw new Error(`Error sending Telegram message: ${error}`);
     }
@@ -1753,7 +1716,7 @@ var TelegramTestSuite = class {
         mockContext,
         messageContent
       );
-      logger4.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}`);
     }
@@ -1794,7 +1757,7 @@ var TelegramTestSuite = class {
       if (!this.bot) throw new Error("Bot not initialized.");
       if (!this.messageManager) throw new Error("MessageManager not initialized.");
       const chatId = this.validateChatId(runtime);
-      const fileId = await this.getFileId(chatId, TEST_IMAGE_URL);
+      const fileId = await this.getFileId(String(chatId), TEST_IMAGE_URL);
       const mockMessage = {
         message_id: 12345,
         chat: { id: chatId, type: "private" },
@@ -1814,7 +1777,7 @@ var TelegramTestSuite = class {
         throw new Error("Error processing Telegram image or description not found");
       }
       const { description } = result;
-      logger4.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}`);
     }
@@ -1830,7 +1793,7 @@ var TelegramTestSuite = class {
       }
       return message.photo[message.photo.length - 1].file_id;
     } catch (error) {
-      logger4.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;
     }
   }