@elizaos/plugin-telegram 2.0.0-alpha.9 → 2.0.0-beta.1

package/dist/index.js

@@ -1,3 +1,322 @@
+import {
+  TelegramAccountAuthSession,
+  clearTelegramAccountAuthState,
+  clearTelegramAccountSession,
+  defaultTelegramAccountDeviceModel,
+  defaultTelegramAccountSystemVersion,
+  loadTelegramAccountSessionString,
+  resolveTelegramAccountSessionFile,
+  saveTelegramAccountSessionString,
+  telegramAccountAuthStateExists,
+  telegramAccountSessionExists
+} from "./chunk-KFEFF6RI.js";
+
+// src/index.ts
+import { getConnectorAccountManager, logger as logger7 } from "@elizaos/core";
+
+// src/account-setup-routes.ts
+function isConnectorSetupService(service) {
+  if (!service || typeof service !== "object") {
+    return false;
+  }
+  const candidate = service;
+  return typeof candidate.getConfig === "function" && typeof candidate.updateConfig === "function" && typeof candidate.persistConfig === "function";
+}
+function getSetupService(runtime) {
+  const service = runtime.getService("connector-setup");
+  return isConnectorSetupService(service) ? service : null;
+}
+var telegramAccountAuthSession = null;
+async function stopTelegramAccountAuthSession() {
+  if (telegramAccountAuthSession) {
+    try {
+      await telegramAccountAuthSession.stop();
+    } catch {
+    }
+    telegramAccountAuthSession = null;
+  }
+}
+function readConnectorConfig(config) {
+  const connectors = config.connectors;
+  const raw = connectors?.telegramAccount;
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    return {};
+  }
+  return raw;
+}
+function hasConfiguredTelegramAccount(connConfig) {
+  return Boolean(
+    typeof connConfig.phone === "string" && connConfig.phone.trim() && (typeof connConfig.appId === "string" || typeof connConfig.appId === "number") && typeof connConfig.appHash === "string" && connConfig.appHash.trim() && typeof connConfig.deviceModel === "string" && connConfig.deviceModel.trim() && typeof connConfig.systemVersion === "string" && connConfig.systemVersion.trim() && connConfig.enabled !== false
+  );
+}
+function resolveConfiguredPhone(runtime, connConfig) {
+  if (typeof connConfig.phone === "string" && connConfig.phone.trim().length > 0) {
+    return connConfig.phone.trim();
+  }
+  const setting = runtime.getSetting("TELEGRAM_ACCOUNT_PHONE");
+  return typeof setting === "string" && setting.trim().length > 0 ? setting.trim() : null;
+}
+function resolveService(runtime) {
+  const service = runtime.getService("telegram-account");
+  return service ?? null;
+}
+function isServiceConnected(service) {
+  if (!service) {
+    return false;
+  }
+  if (typeof service.isConnected === "function") {
+    return service.isConnected();
+  }
+  const withFlags = service;
+  if (typeof withFlags.isServiceConnected === "function") {
+    return withFlags.isServiceConnected();
+  }
+  return withFlags.connected === true;
+}
+function statusFromState(runtime, config) {
+  const connectorConfig = readConnectorConfig(config);
+  const configured = hasConfiguredTelegramAccount(connectorConfig);
+  const sessExists = telegramAccountSessionExists();
+  const authSnapshot = telegramAccountAuthSession?.getSnapshot() ?? null;
+  const service = resolveService(runtime);
+  const serviceConnected = isServiceConnected(service);
+  const serviceAccount = typeof service?.getAccountSummary === "function" ? service.getAccountSummary() : null;
+  const fallbackPhone = resolveConfiguredPhone(runtime, connectorConfig);
+  let status = authSnapshot?.status ?? (serviceConnected ? "connected" : configured || sessExists ? "configured" : "idle");
+  if (serviceConnected && status === "configured") {
+    status = "connected";
+  }
+  return {
+    available: true,
+    status,
+    configured,
+    sessionExists: sessExists,
+    serviceConnected,
+    restartRequired: status === "configured" && !serviceConnected,
+    hasAppCredentials: Boolean(
+      (typeof connectorConfig.appId === "string" || typeof connectorConfig.appId === "number") && typeof connectorConfig.appHash === "string" && connectorConfig.appHash.trim().length > 0
+    ),
+    phone: authSnapshot?.phone ?? fallbackPhone,
+    isCodeViaApp: authSnapshot?.isCodeViaApp ?? false,
+    account: authSnapshot?.account ?? serviceAccount ?? null,
+    error: authSnapshot?.error ?? null
+  };
+}
+function ensureConnectorBlock(config) {
+  if (!config.connectors) {
+    config.connectors = {};
+  }
+  const connectors = config.connectors;
+  if (!connectors.telegramAccount || typeof connectors.telegramAccount !== "object" || Array.isArray(connectors.telegramAccount)) {
+    connectors.telegramAccount = {};
+  }
+  return connectors.telegramAccount;
+}
+function createSessionOptions(config) {
+  const connectorConfig = readConnectorConfig(config);
+  return {
+    deviceModel: typeof connectorConfig.deviceModel === "string" && connectorConfig.deviceModel.trim().length > 0 ? connectorConfig.deviceModel.trim() : defaultTelegramAccountDeviceModel(),
+    systemVersion: typeof connectorConfig.systemVersion === "string" && connectorConfig.systemVersion.trim().length > 0 ? connectorConfig.systemVersion.trim() : defaultTelegramAccountSystemVersion()
+  };
+}
+function ensureAuthSession(config) {
+  if (telegramAccountAuthSession) {
+    return telegramAccountAuthSession;
+  }
+  if (!telegramAccountAuthStateExists()) {
+    return null;
+  }
+  telegramAccountAuthSession = new TelegramAccountAuthSession(
+    createSessionOptions(config)
+  );
+  return telegramAccountAuthSession;
+}
+async function handleStatus(_req, res, runtime) {
+  const setupService = getSetupService(runtime);
+  const config = setupService?.getConfig() ?? {};
+  ensureAuthSession(config);
+  res.status(200).json(statusFromState(runtime, config));
+}
+async function handleAuthStart(req, res, runtime) {
+  const body = req.body ?? {};
+  const setupService = getSetupService(runtime);
+  const config = setupService?.getConfig() ?? {};
+  const connectorConfig = readConnectorConfig(config);
+  const phone = typeof body.phone === "string" && body.phone.trim() || resolveConfiguredPhone(runtime, connectorConfig);
+  if (!phone) {
+    res.status(400).json({ error: "telegram phone number is required" });
+    return;
+  }
+  await telegramAccountAuthSession?.stop();
+  telegramAccountAuthSession = new TelegramAccountAuthSession(
+    createSessionOptions(config)
+  );
+  const credentials = hasConfiguredTelegramAccount(connectorConfig) && (typeof connectorConfig.appId === "string" || typeof connectorConfig.appId === "number") && typeof connectorConfig.appHash === "string" ? {
+    apiId: Number(connectorConfig.appId),
+    apiHash: connectorConfig.appHash
+  } : null;
+  try {
+    await telegramAccountAuthSession.start({ phone, credentials });
+    const resolved = telegramAccountAuthSession.getResolvedConnectorConfig();
+    if (resolved && setupService) {
+      setupService.updateConfig((cfg) => {
+        Object.assign(ensureConnectorBlock(cfg), resolved);
+      });
+    }
+    const freshConfig = setupService?.getConfig() ?? config;
+    res.status(200).json(statusFromState(runtime, freshConfig));
+  } catch (error) {
+    res.status(500).json({
+      error: error instanceof Error ? error.message : String(error)
+    });
+  }
+}
+async function handleAuthSubmit(req, res, runtime) {
+  const body = req.body ?? {};
+  const setupService = getSetupService(runtime);
+  const config = setupService?.getConfig() ?? {};
+  if (!ensureAuthSession(config)) {
+    res.status(400).json({ error: "telegram login session has not been started" });
+    return;
+  }
+  if (!telegramAccountAuthSession) {
+    res.status(400).json({ error: "telegram login session has not been started" });
+    return;
+  }
+  try {
+    await telegramAccountAuthSession.submit(body);
+    const resolved = telegramAccountAuthSession.getResolvedConnectorConfig();
+    if (resolved && setupService) {
+      setupService.updateConfig((cfg) => {
+        Object.assign(ensureConnectorBlock(cfg), resolved);
+      });
+    }
+    const freshConfig = setupService?.getConfig() ?? config;
+    res.status(200).json(statusFromState(runtime, freshConfig));
+  } catch (error) {
+    res.status(500).json({
+      error: error instanceof Error ? error.message : String(error)
+    });
+  }
+}
+async function handleDisconnect(_req, res, runtime) {
+  await telegramAccountAuthSession?.stop();
+  telegramAccountAuthSession = null;
+  clearTelegramAccountAuthState();
+  clearTelegramAccountSession();
+  const service = resolveService(runtime);
+  if (typeof service?.stop === "function") {
+    await service.stop();
+  }
+  const setupService = getSetupService(runtime);
+  if (setupService) {
+    setupService.updateConfig((cfg) => {
+      const connectors = cfg.connectors;
+      if (connectors?.telegramAccount) {
+        delete connectors.telegramAccount;
+      }
+    });
+  }
+  const config = setupService?.getConfig() ?? {};
+  res.status(200).json({
+    ok: true,
+    ...statusFromState(runtime, config)
+  });
+}
+var telegramAccountRoutes = [
+  {
+    type: "GET",
+    path: "/api/telegram-account/status",
+    handler: handleStatus,
+    rawPath: true
+  },
+  {
+    type: "POST",
+    path: "/api/telegram-account/auth/start",
+    handler: handleAuthStart,
+    rawPath: true
+  },
+  {
+    type: "POST",
+    path: "/api/telegram-account/auth/submit",
+    handler: handleAuthSubmit,
+    rawPath: true
+  },
+  {
+    type: "POST",
+    path: "/api/telegram-account/disconnect",
+    handler: handleDisconnect,
+    rawPath: true
+  }
+];
+
+// src/accounts.ts
+var DEFAULT_ACCOUNT_ID = "default";
+function readNonEmptyString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function normalizeTelegramAccountId(accountId) {
+  return readNonEmptyString(accountId) ?? DEFAULT_ACCOUNT_ID;
+}
+function getTelegramMultiAccountConfig(runtime) {
+  const characterTelegram = runtime.character?.settings?.telegram;
+  return {
+    enabled: characterTelegram?.enabled,
+    botToken: characterTelegram?.botToken,
+    apiRoot: characterTelegram?.apiRoot,
+    accounts: characterTelegram?.accounts
+  };
+}
+function listTelegramAccountIds(runtime) {
+  const accounts = getTelegramMultiAccountConfig(runtime).accounts;
+  if (!accounts || typeof accounts !== "object") {
+    return [DEFAULT_ACCOUNT_ID];
+  }
+  const ids = Object.keys(accounts).filter(Boolean);
+  return ids.length > 0 ? ids.slice().sort((a, b) => a.localeCompare(b)) : [DEFAULT_ACCOUNT_ID];
+}
+function resolveDefaultTelegramAccountId(runtime) {
+  const ids = listTelegramAccountIds(runtime);
+  return ids.includes(DEFAULT_ACCOUNT_ID) ? DEFAULT_ACCOUNT_ID : ids[0] ?? DEFAULT_ACCOUNT_ID;
+}
+function getAccountConfig(runtime, accountId) {
+  const accounts = getTelegramMultiAccountConfig(runtime).accounts;
+  return accounts && typeof accounts === "object" ? accounts[accountId] : void 0;
+}
+function resolveTelegramBotToken(runtime, accountId, merged) {
+  const configToken = readNonEmptyString(merged.botToken);
+  if (configToken) {
+    return configToken;
+  }
+  if (accountId !== DEFAULT_ACCOUNT_ID) {
+    return void 0;
+  }
+  return readNonEmptyString(runtime.getSetting("TELEGRAM_BOT_TOKEN")) ?? readNonEmptyString(process.env.TELEGRAM_BOT_TOKEN);
+}
+function resolveTelegramAccount(runtime, accountId) {
+  const normalizedAccountId = normalizeTelegramAccountId(accountId);
+  const multi = getTelegramMultiAccountConfig(runtime);
+  const accountConfig = getAccountConfig(runtime, normalizedAccountId) ?? {};
+  const merged = {
+    enabled: multi.enabled,
+    botToken: multi.botToken,
+    apiRoot: multi.apiRoot,
+    ...accountConfig
+  };
+  const apiRoot = readNonEmptyString(merged.apiRoot) ?? readNonEmptyString(runtime.getSetting("TELEGRAM_API_ROOT")) ?? readNonEmptyString(process.env.TELEGRAM_API_ROOT) ?? "https://api.telegram.org";
+  return {
+    accountId: normalizedAccountId,
+    enabled: multi.enabled !== false && merged.enabled !== false,
+    name: readNonEmptyString(merged.name),
+    botToken: resolveTelegramBotToken(runtime, normalizedAccountId, merged),
+    apiRoot,
+    config: merged
+  };
+}
+function listEnabledTelegramAccounts(runtime) {
+  return listTelegramAccountIds(runtime).map((accountId) => resolveTelegramAccount(runtime, accountId)).filter((account) => account.enabled && account.botToken);
+}
+
 // src/constants.ts
 var MESSAGE_CONSTANTS = {
   MAX_MESSAGES: 50,
@@ -12,38 +331,97 @@ var MESSAGE_CONSTANTS = {
 };
 var TELEGRAM_SERVICE_NAME = "telegram";
 
-// src/service.ts
-import {
-  ChannelType as ChannelType2,
-  EventType as EventType2,
-  Role,
-  Service,
-  createUniqueUuid as createUniqueUuid2,
-  logger as logger3
-} from "@elizaos/core";
-import { Telegraf } from "telegraf";
+// src/connector-account-provider.ts
+function nowMs() {
+  return Date.now();
+}
+function synthesizeAccount(accountId, name, externalId) {
+  return {
+    id: accountId,
+    provider: TELEGRAM_SERVICE_NAME,
+    label: name ?? `Telegram (${accountId})`,
+    role: "AGENT",
+    purpose: ["messaging"],
+    accessGate: "open",
+    status: "connected",
+    externalId,
+    displayHandle: name,
+    createdAt: nowMs(),
+    updatedAt: nowMs(),
+    metadata: {
+      synthesized: true,
+      source: "env"
+    }
+  };
+}
+function createTelegramConnectorAccountProvider(runtime) {
+  return {
+    provider: TELEGRAM_SERVICE_NAME,
+    label: "Telegram",
+    listAccounts: async (manager) => {
+      const persisted = await manager.getStorage().listAccounts(TELEGRAM_SERVICE_NAME);
+      const persistedById = new Map(persisted.map((a) => [a.id, a]));
+      const enabled = listEnabledTelegramAccounts(runtime);
+      const synthesized = enabled.filter((account) => !persistedById.has(account.accountId)).map(
+        (account) => synthesizeAccount(account.accountId, account.name, void 0)
+      );
+      if (synthesized.length === 0 && persisted.length === 0) {
+        const fallback = resolveTelegramAccount(runtime, DEFAULT_ACCOUNT_ID);
+        if (fallback.botToken) {
+          synthesized.push(
+            synthesizeAccount(DEFAULT_ACCOUNT_ID, fallback.name, void 0)
+          );
+        }
+      }
+      return [...persisted, ...synthesized];
+    },
+    createAccount: async (input) => {
+      return {
+        ...input,
+        provider: TELEGRAM_SERVICE_NAME,
+        role: input.role ?? "AGENT",
+        purpose: input.purpose ?? ["messaging"],
+        accessGate: input.accessGate ?? "open",
+        status: input.status ?? "connected"
+      };
+    },
+    patchAccount: async (_accountId, patch) => {
+      return { ...patch, provider: TELEGRAM_SERVICE_NAME };
+    },
+    deleteAccount: async () => {
+    }
+    // Telegram bots use a long-lived bot token; no OAuth flow exists.
+    // startOAuth / completeOAuth are intentionally omitted.
+  };
+}
 
 // src/messageManager.ts
+import fs from "fs";
 import {
   ChannelType,
+  createUniqueUuid,
   EventType,
+  lifeOpsPassiveConnectorsEnabled,
+  logger as logger2,
   ModelType,
-  ServiceType,
-  createUniqueUuid,
-  logger as logger2
+  ServiceType
 } from "@elizaos/core";
 import { Markup as Markup2 } from "telegraf";
 
 // src/utils.ts
-import { Markup } from "telegraf";
 import { logger } from "@elizaos/core";
+import { Markup } from "telegraf";
 var TELEGRAM_RESERVED_REGEX = /([_*[\]()~`>#+\-=|{}.!\\])/g;
 function escapePlainText(text) {
-  if (!text) return "";
+  if (!text) {
+    return "";
+  }
   return text.replace(TELEGRAM_RESERVED_REGEX, "\\$1");
 }
 function escapePlainTextPreservingBlockquote(text) {
-  if (!text) return "";
+  if (!text) {
+    return "";
+  }
   return text.split("\n").map((line) => {
     const match = line.match(/^(>+\s?)(.*)$/);
     if (match) {
@@ -53,11 +431,15 @@ function escapePlainTextPreservingBlockquote(text) {
   }).join("\n");
 }
 function escapeCode(text) {
-  if (!text) return "";
+  if (!text) {
+    return "";
+  }
   return text.replace(/([`\\])/g, "\\$1");
 }
 function escapeUrl(url) {
-  if (!url) return "";
+  if (!url) {
+    return "";
+  }
   return url.replace(/([)\\])/g, "\\$1");
 }
 function convertMarkdownToTelegram(markdown) {
@@ -68,14 +450,18 @@ function convertMarkdownToTelegram(markdown) {
     return placeholder;
   }
   let converted = markdown;
-  converted = converted.replace(/```(\w+)?\n([\s\S]*?)```/g, (_match, lang, code) => {
-    const escapedCode = escapeCode(code);
-    const formatted = "```" + (lang || "") + "\n" + escapedCode + "```";
-    return storeReplacement(formatted);
-  });
+  converted = converted.replace(
+    /```(\w+)?\n([\s\S]*?)```/g,
+    (_match, lang, code) => {
+      const escapedCode = escapeCode(code);
+      const formatted = `\`\`\`${lang || ""}
+${escapedCode}\`\`\``;
+      return storeReplacement(formatted);
+    }
+  );
   converted = converted.replace(/`([^`]+)`/g, (_match, code) => {
     const escapedCode = escapeCode(code);
-    const formatted = "`" + escapedCode + "`";
+    const formatted = `\`${escapedCode}\``;
     return storeReplacement(formatted);
   });
   converted = converted.replace(
@@ -97,20 +483,26 @@ function convertMarkdownToTelegram(markdown) {
     const formatted = `~${formattedContent}~`;
     return storeReplacement(formatted);
   });
-  converted = converted.replace(/(?<!\*)\*([^*\n]+)\*(?!\*)/g, (_match, content) => {
-    const formattedContent = escapePlainText(content);
-    const formatted = `_${formattedContent}_`;
-    return storeReplacement(formatted);
-  });
+  converted = converted.replace(
+    /(?<!\*)\*([^*\n]+)\*(?!\*)/g,
+    (_match, content) => {
+      const formattedContent = escapePlainText(content);
+      const formatted = `_${formattedContent}_`;
+      return storeReplacement(formatted);
+    }
+  );
   converted = converted.replace(/_([^_\n]+)_/g, (_match, content) => {
     const formattedContent = escapePlainText(content);
     const formatted = `_${formattedContent}_`;
     return storeReplacement(formatted);
   });
-  converted = converted.replace(/^(#{1,6})\s*(.*)$/gm, (_match, _hashes, headerContent) => {
-    const formatted = `*${escapePlainText(headerContent.trim())}*`;
-    return storeReplacement(formatted);
-  });
+  converted = converted.replace(
+    /^(#{1,6})\s*(.*)$/gm,
+    (_match, _hashes, headerContent) => {
+      const formatted = `*${escapePlainText(headerContent.trim())}*`;
+      return storeReplacement(formatted);
+    }
+  );
   const NULL_CHAR = String.fromCharCode(0);
   const PLACEHOLDER_PATTERN = new RegExp(`(${NULL_CHAR}\\d+${NULL_CHAR})`, "g");
   const PLACEHOLDER_TEST = new RegExp(`^${NULL_CHAR}\\d+${NULL_CHAR}$`);
@@ -123,16 +515,21 @@ function convertMarkdownToTelegram(markdown) {
     }
   }).join("");
   const finalResult = finalEscaped.replace(PLACEHOLDER_REPLACE, (_, index) => {
-    return replacements[parseInt(index)];
+    return replacements[Number.parseInt(index, 10)];
   });
   return finalResult;
 }
 function convertToTelegramButtons(buttons) {
-  if (!buttons) return [];
+  if (!buttons) {
+    return [];
+  }
   const telegramButtons = [];
   for (const button of buttons) {
-    if (!button || !button.text || !button.url) {
-      logger.warn({ button }, "Invalid button configuration, skipping");
+    if (!button?.text || !button.url) {
+      logger.warn(
+        { src: "plugin:telegram", button },
+        "Invalid button configuration, skipping"
+      );
       continue;
     }
     let telegramButton;
@@ -144,7 +541,10 @@ function convertToTelegramButtons(buttons) {
         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");
+        logger.warn(
+          { src: "plugin:telegram", buttonKind: button.kind },
+          "Unknown button kind, treating as URL button"
+        );
         telegramButton = Markup.button.url(button.text, button.url);
         break;
     }
@@ -153,15 +553,20 @@ function convertToTelegramButtons(buttons) {
   return telegramButtons;
 }
 function cleanText(text) {
-  if (!text) return "";
+  if (!text) {
+    return "";
+  }
   return text.split("\0").join("");
 }
 
 // src/messageManager.ts
-import fs from "fs";
 var MAX_MESSAGE_LENGTH = 4096;
+function isPdfTextService(service) {
+  return typeof service === "object" && service !== null && typeof service.convertPdfToText === "function";
+}
 var getChannelType = (chat) => {
-  switch (chat.type) {
+  const chatType = chat.type;
+  switch (chatType) {
     case "private":
       return ChannelType.DM;
     case "group":
@@ -169,21 +574,26 @@ var getChannelType = (chat) => {
     case "channel":
       return ChannelType.GROUP;
     default:
-      throw new Error(`Unrecognized Telegram chat type: ${chat.type}`);
+      throw new Error(`Unrecognized Telegram chat type: ${String(chatType)}`);
   }
 };
 var MessageManager = class {
   bot;
   runtime;
+  accountId;
   /**
    * Constructor for creating a new instance of a BotAgent.
    *
    * @param {Telegraf<Context>} bot - The Telegraf instance used for interacting with the bot platform.
    * @param {IAgentRuntime} runtime - The runtime environment for the agent.
    */
-  constructor(bot, runtime) {
+  constructor(bot, runtime, accountId = "default") {
     this.bot = bot;
     this.runtime = runtime;
+    this.accountId = accountId;
+  }
+  scopedTelegramKey(key) {
+    return this.accountId === "default" ? key : `${this.accountId}:${key}`;
   }
   /**
    * Process an image from a Telegram message to extract the image URL and description.
@@ -194,13 +604,22 @@ var MessageManager = class {
   async processImage(message) {
     try {
       let imageUrl = null;
-      logger2.debug({ src: "plugin:telegram", agentId: this.runtime.agentId, messageId: message.message_id }, "Processing image from message");
+      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/") && !message.document?.mime_type?.startsWith("application/pdf")) {
-        const fileLink = await this.bot.telegram.getFileLink(message.document.file_id);
+        const fileLink = await this.bot.telegram.getFileLink(
+          message.document.file_id
+        );
         imageUrl = fileLink.toString();
       }
       if (imageUrl) {
@@ -212,7 +631,14 @@ var MessageManager = class {
 ${description}]` };
       }
     } catch (error) {
-      logger2.error({ src: "plugin:telegram", agentId: this.runtime.agentId, error: error instanceof Error ? error.message : String(error) }, "Error processing image");
+      logger2.error(
+        {
+          src: "plugin:telegram",
+          agentId: this.runtime.agentId,
+          error: error instanceof Error ? error.message : String(error)
+        },
+        "Error processing image"
+      );
     }
     return null;
   }
@@ -231,7 +657,16 @@ ${description}]` };
       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");
+      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);
@@ -247,7 +682,14 @@ Size: ${document.file_size || 0} bytes]`,
         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");
+      logger2.error(
+        {
+          src: "plugin:telegram",
+          agentId: this.runtime.agentId,
+          error: error instanceof Error ? error.message : String(error)
+        },
+        "Error processing document"
+      );
       return null;
     }
   }
@@ -255,7 +697,9 @@ Size: ${document.file_size || 0} bytes]`,
    * Get the appropriate document processor based on MIME type.
    */
   getDocumentProcessor(mimeType) {
-    if (!mimeType) return null;
+    if (!mimeType) {
+      return null;
+    }
     const processors = {
       "application/pdf": this.processPdfDocument.bind(this),
       "text/": this.processTextDocument.bind(this),
@@ -274,9 +718,13 @@ Size: ${document.file_size || 0} bytes]`,
    */
   async processPdfDocument(document, documentUrl) {
     try {
-      const pdfService = this.runtime.getService(ServiceType.PDF);
+      const pdfServiceCandidate = this.runtime.getService(ServiceType.PDF);
+      const pdfService = isPdfTextService(pdfServiceCandidate) ? pdfServiceCandidate : null;
       if (!pdfService) {
-        logger2.warn({ src: "plugin:telegram", agentId: this.runtime.agentId }, "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: "",
@@ -294,7 +742,15 @@ Unable to extract text content]`,
       }
       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");
+      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,
@@ -306,7 +762,15 @@ Text extracted successfully: ${text.length} characters]`,
         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");
+      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: "",
@@ -329,7 +793,15 @@ Error: Unable to extract text content]`,
         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");
+      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,
@@ -341,7 +813,15 @@ Text extracted successfully: ${text.length} characters]`,
         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");
+      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: "",
@@ -363,7 +843,7 @@ Error: Unable to read content]`,
    */
   async processMessage(message) {
     let processedContent = "";
-    let attachments = [];
+    const attachments = [];
     if ("text" in message && message.text) {
       processedContent = message.text;
     } else if ("caption" in message && message.caption) {
@@ -374,7 +854,9 @@ Error: Unable to read content]`,
       const documentInfo = await this.processDocument(message);
       if (documentInfo) {
         try {
-          const fileLink = await this.bot.telegram.getFileLink(document.file_id);
+          const fileLink = await this.bot.telegram.getFileLink(
+            document.file_id
+          );
           const title = documentInfo.title;
           const fullText = documentInfo.fullText;
           if (fullText) {
@@ -398,9 +880,24 @@ ${fullText}
             description: documentInfo.formattedDescription,
             text: fullText
           });
-          logger2.debug({ src: "plugin:telegram", agentId: this.runtime.agentId, fileName: documentInfo.fileName }, "Document processed successfully");
+          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");
+          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: "",
@@ -440,7 +937,15 @@ Type: ${document.mime_type || "unknown"}`
         });
       }
     }
-    logger2.debug({ src: "plugin:telegram", agentId: this.runtime.agentId, hasContent: !!processedContent, attachmentsCount: attachments.length }, "Message processed");
+    logger2.debug(
+      {
+        src: "plugin:telegram",
+        agentId: this.runtime.agentId,
+        hasContent: !!processedContent,
+        attachmentsCount: attachments.length
+      },
+      "Message processed"
+    );
     return { processedContent, attachments };
   }
   /**
@@ -451,7 +956,7 @@ Type: ${document.mime_type || "unknown"}`
    * @param {number} [replyToMessageId] - The ID of the message to reply to, if any
    * @returns {Promise<Message.TextMessage[]>} - An array of TextMessage objects representing the messages sent
    */
-  async sendMessageInChunks(ctx, content, replyToMessageId) {
+  async sendMessageInChunks(ctx, content, replyToMessageId, messageThreadId) {
     if (content.attachments && content.attachments.length > 0) {
       content.attachments.map(async (attachment) => {
         const typeMap = {
@@ -461,7 +966,7 @@ Type: ${document.mime_type || "unknown"}`
           video: "video" /* VIDEO */,
           audio: "audio" /* AUDIO */
         };
-        let mediaType = void 0;
+        let mediaType;
         for (const prefix in typeMap) {
           if (attachment.contentType?.startsWith(prefix)) {
             mediaType = typeMap[prefix];
@@ -473,7 +978,12 @@ Type: ${document.mime_type || "unknown"}`
             `Unsupported Telegram attachment content type: ${attachment.contentType}`
           );
         }
-        await this.sendMedia(ctx, attachment.url, mediaType, attachment.description);
+        await this.sendMedia(
+          ctx,
+          attachment.url,
+          mediaType,
+          attachment.description
+        );
       });
       return [];
     } else {
@@ -481,21 +991,32 @@ Type: ${document.mime_type || "unknown"}`
       const sentMessages = [];
       const telegramButtons = convertToTelegramButtons(content.buttons ?? []);
       if (!ctx.chat) {
-        logger2.error({ src: "plugin:telegram", agentId: this.runtime.agentId }, "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({ src: "plugin:telegram", agentId: this.runtime.agentId }, "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, {
-          reply_parameters: i === 0 && replyToMessageId ? { message_id: replyToMessageId } : void 0,
-          parse_mode: "MarkdownV2",
-          ...Markup2.inlineKeyboard(telegramButtons)
-        });
+        const sentMessage = await ctx.telegram.sendMessage(
+          ctx.chat.id,
+          chunk,
+          {
+            reply_parameters: i === 0 && replyToMessageId ? { message_id: replyToMessageId } : void 0,
+            message_thread_id: messageThreadId,
+            parse_mode: "MarkdownV2",
+            ...Markup2.inlineKeyboard(telegramButtons)
+          }
+        );
         sentMessages.push(sentMessage);
       }
       return sentMessages;
@@ -544,9 +1065,26 @@ Type: ${document.mime_type || "unknown"}`
           fileStream.destroy();
         }
       }
-      logger2.debug({ src: "plugin:telegram", agentId: this.runtime.agentId, mediaType: type, mediaPath }, "Media sent successfully");
+      logger2.debug(
+        {
+          src: "plugin:telegram",
+          agentId: this.runtime.agentId,
+          mediaType: type,
+          mediaPath
+        },
+        "Media sent successfully"
+      );
     } catch (error) {
-      logger2.error({ src: "plugin:telegram", agentId: this.runtime.agentId, mediaType: type, mediaPath, error: error instanceof Error ? error.message : String(error) }, "Failed to send media");
+      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;
     }
   }
@@ -558,18 +1096,24 @@ Type: ${document.mime_type || "unknown"}`
    */
   splitMessage(text) {
     const chunks = [];
-    if (!text) return chunks;
+    if (!text) {
+      return chunks;
+    }
     let currentChunk = "";
     const lines = text.split("\n");
     for (const line of lines) {
       if (currentChunk.length + line.length + 1 <= MAX_MESSAGE_LENGTH) {
         currentChunk += (currentChunk ? "\n" : "") + line;
       } else {
-        if (currentChunk) chunks.push(currentChunk);
+        if (currentChunk) {
+          chunks.push(currentChunk);
+        }
         currentChunk = line;
       }
     }
-    if (currentChunk) chunks.push(currentChunk);
+    if (currentChunk) {
+      chunks.push(currentChunk);
+    }
     return chunks;
   }
   /**
@@ -578,18 +1122,35 @@ Type: ${document.mime_type || "unknown"}`
    * @returns {Promise<void>}
    */
   async handleMessage(ctx) {
-    if (!ctx.message || !ctx.from) return;
+    if (!ctx.message || !ctx.from) {
+      return;
+    }
     const message = ctx.message;
     try {
-      const entityId = createUniqueUuid(this.runtime, ctx.from.id.toString());
+      const telegramUserId = ctx.from.id.toString();
+      const entityId = createUniqueUuid(
+        this.runtime,
+        this.scopedTelegramKey(telegramUserId)
+      );
       const threadId = "is_topic_message" in message && message.is_topic_message ? message.message_thread_id?.toString() : void 0;
       if (!ctx.chat) {
-        logger2.error({ src: "plugin:telegram", agentId: this.runtime.agentId }, "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 telegramChatId = ctx.chat.id.toString();
+      const scopedRoomKey = this.scopedTelegramKey(telegramRoomid);
+      const scopedChatKey = this.scopedTelegramKey(telegramChatId);
+      const roomId = createUniqueUuid(this.runtime, scopedRoomKey);
+      const worldId = createUniqueUuid(this.runtime, scopedChatKey);
+      const telegramMessageId = message.message_id.toString();
+      const messageId = createUniqueUuid(
+        this.runtime,
+        this.scopedTelegramKey(telegramMessageId)
+      );
       const { processedContent, attachments } = await this.processMessage(message);
       const cleanedContent = cleanText(processedContent);
       const cleanedAttachments = attachments.map((att) => ({
@@ -603,16 +1164,17 @@ Type: ${document.mime_type || "unknown"}`
       }
       const chat = message.chat;
       const channelType = getChannelType(chat);
-      const sourceId = createUniqueUuid(this.runtime, "" + chat.id);
       await this.runtime.ensureConnection({
         entityId,
         roomId,
+        roomName: "title" in chat && typeof chat.title === "string" && chat.title || "first_name" in chat && typeof chat.first_name === "string" && chat.first_name || "username" in chat && typeof chat.username === "string" && chat.username || telegramRoomid,
         userName: ctx.from.username,
         name: ctx.from.first_name,
+        userId: telegramUserId,
         source: "telegram",
         channelId: telegramRoomid,
         type: channelType,
-        worldId: createUniqueUuid(this.runtime, roomId),
+        worldId,
         worldName: telegramRoomid
       });
       const memory = {
@@ -624,44 +1186,76 @@ Type: ${document.mime_type || "unknown"}`
           text: cleanedContent || " ",
           attachments: cleanedAttachments,
           source: "telegram",
+          metadata: { accountId: this.accountId },
           channelType,
-          inReplyTo: "reply_to_message" in message && message.reply_to_message ? createUniqueUuid(this.runtime, message.reply_to_message.message_id.toString()) : void 0
+          inReplyTo: "reply_to_message" in message && message.reply_to_message ? createUniqueUuid(
+            this.runtime,
+            this.scopedTelegramKey(
+              message.reply_to_message.message_id.toString()
+            )
+          ) : void 0
         },
         metadata: {
+          type: "message",
+          source: "telegram",
+          accountId: this.accountId,
+          provider: "telegram",
+          timestamp: message.date * 1e3,
           entityName: ctx.from.first_name,
           entityUserName: ctx.from.username,
           fromBot: ctx.from.is_bot,
-          // include very technical/exact reference to this user for security reasons
-          // don't remove or change this, spartan needs this
-          fromId: chat.id,
-          sourceId,
-          // why message? all Memories contain content (which is basically a message)
-          // what are the other types? see MemoryType
-          type: "message"
-          // MemoryType.MESSAGE
-          // scope: `shared`, `private`, or `room`
+          fromId: telegramUserId,
+          sourceId: entityId,
+          chatType: chat.type,
+          messageIdFull: telegramMessageId,
+          sender: {
+            id: telegramUserId,
+            name: ctx.from.first_name,
+            username: ctx.from.username
+          },
+          telegram: {
+            chatId: telegramChatId,
+            messageId: telegramMessageId,
+            threadId
+          },
+          telegramUserId,
+          telegramChatId
         },
         createdAt: message.date * 1e3
       };
-      const callback = async (content, _files) => {
+      const callback = async (content, _actionName) => {
         try {
-          if (!content.text) return [];
+          if (!content.text) {
+            return [];
+          }
           let sentMessages = false;
           if (content?.channelType === "DM") {
             sentMessages = [];
             if (ctx.from) {
-              const res = await this.bot.telegram.sendMessage(ctx.from.id, content.text);
+              const res = await this.bot.telegram.sendMessage(
+                ctx.from.id,
+                content.text
+              );
               sentMessages.push(res);
             }
           } else {
-            sentMessages = await this.sendMessageInChunks(ctx, content, message.message_id);
+            sentMessages = await this.sendMessageInChunks(
+              ctx,
+              content,
+              message.message_id
+            );
+          }
+          if (!Array.isArray(sentMessages)) {
+            return [];
           }
-          if (!Array.isArray(sentMessages)) return [];
           const memories = [];
           for (let i = 0; i < sentMessages.length; i++) {
             const sentMessage = sentMessages[i];
             const responseMemory = {
-              id: createUniqueUuid(this.runtime, sentMessage.message_id.toString()),
+              id: createUniqueUuid(
+                this.runtime,
+                this.scopedTelegramKey(sentMessage.message_id.toString())
+              ),
               entityId: this.runtime.agentId,
               agentId: this.runtime.agentId,
               roomId,
@@ -670,7 +1264,25 @@ Type: ${document.mime_type || "unknown"}`
                 source: "telegram",
                 text: sentMessage.text,
                 inReplyTo: messageId,
-                channelType
+                channelType,
+                metadata: { accountId: this.accountId }
+              },
+              metadata: {
+                type: "message",
+                source: "telegram",
+                accountId: this.accountId,
+                provider: "telegram",
+                timestamp: sentMessage.date * 1e3,
+                fromBot: true,
+                fromId: this.runtime.agentId,
+                sourceId: this.runtime.agentId,
+                chatType: chat.type,
+                messageIdFull: sentMessage.message_id.toString(),
+                telegram: {
+                  chatId: sentMessage.chat.id,
+                  messageId: sentMessage.message_id.toString(),
+                  threadId
+                }
               },
               createdAt: sentMessage.date * 1e3
             };
@@ -679,26 +1291,65 @@ Type: ${document.mime_type || "unknown"}`
           }
           return memories;
         } catch (error) {
-          logger2.error({ src: "plugin:telegram", agentId: this.runtime.agentId, error: error instanceof Error ? error.message : String(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.hasElizaOS()) {
-        await this.runtime.elizaOS.handleMessage(this.runtime.agentId, memory, {
-          onResponse: async (content) => {
-            await callback(content);
-          }
-        });
+      const telegramAutoReplyRaw = this.runtime.getSetting(
+        "TELEGRAM_AUTO_REPLY"
+      );
+      const telegramAutoReply = !lifeOpsPassiveConnectorsEnabled(this.runtime) && (telegramAutoReplyRaw === true || telegramAutoReplyRaw === "true");
+      if (!telegramAutoReply) {
+        try {
+          await this.runtime.createMemory(memory, "messages");
+        } catch (persistError) {
+          logger2.warn(
+            {
+              src: "plugin:telegram",
+              agentId: this.runtime.agentId,
+              error: persistError instanceof Error ? persistError.message : String(persistError)
+            },
+            "Failed to persist inbound memory while auto-reply is disabled"
+          );
+        }
+        logger2.debug(
+          { src: "plugin:telegram", agentId: this.runtime.agentId },
+          "Auto-reply disabled (TELEGRAM_AUTO_REPLY=false); message ingested without response"
+        );
       } else if (this.runtime.messageService) {
-        await this.runtime.messageService.handleMessage(this.runtime, memory, callback);
+        await this.runtime.messageService.handleMessage(
+          this.runtime,
+          memory,
+          callback
+        );
       } else {
-        logger2.error({ src: "plugin:telegram", agentId: this.runtime.agentId }, "Message service is not available");
+        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."
         );
       }
     } catch (error) {
-      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");
+      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;
     }
   }
@@ -708,7 +1359,9 @@ Type: ${document.mime_type || "unknown"}`
    * @returns {Promise<void>} A Promise that resolves when the reaction handling is complete
    */
   async handleReaction(ctx) {
-    if (!ctx.update.message_reaction || !ctx.from) return;
+    if (!ctx.update.message_reaction || !ctx.from) {
+      return;
+    }
     const reaction = ctx.update.message_reaction;
     const reactedToMessageId = reaction.message_id;
     const originalMessagePlaceholder = {
@@ -720,11 +1373,19 @@ Type: ${document.mime_type || "unknown"}`
     const reactionType = reaction.new_reaction[0].type;
     const reactionEmoji = reaction.new_reaction[0].type;
     try {
-      const entityId = createUniqueUuid(this.runtime, ctx.from.id.toString());
-      const roomId = createUniqueUuid(this.runtime, ctx.chat.id.toString());
+      const entityId = createUniqueUuid(
+        this.runtime,
+        this.scopedTelegramKey(ctx.from.id.toString())
+      );
+      const roomId = createUniqueUuid(
+        this.runtime,
+        this.scopedTelegramKey(ctx.chat.id.toString())
+      );
       const reactionId = createUniqueUuid(
         this.runtime,
-        `${reaction.message_id}-${ctx.from.id}-${Date.now()}`
+        this.scopedTelegramKey(
+          `${reaction.message_id}-${ctx.from.id}-${Date.now()}`
+        )
       );
       const memory = {
         id: reactionId,
@@ -735,7 +1396,22 @@ Type: ${document.mime_type || "unknown"}`
           channelType: getChannelType(reaction.chat),
           text: `Reacted with: ${reactionType === "emoji" ? reactionEmoji : reactionType}`,
           source: "telegram",
-          inReplyTo: createUniqueUuid(this.runtime, reaction.message_id.toString())
+          inReplyTo: createUniqueUuid(
+            this.runtime,
+            this.scopedTelegramKey(reaction.message_id.toString())
+          ),
+          metadata: { accountId: this.accountId }
+        },
+        metadata: {
+          type: "custom",
+          eventType: "reaction",
+          source: "telegram",
+          accountId: this.accountId,
+          provider: "telegram",
+          telegram: {
+            chatId: reaction.chat.id.toString(),
+            messageId: reaction.message_id.toString()
+          }
         },
         createdAt: Date.now()
       };
@@ -744,19 +1420,36 @@ Type: ${document.mime_type || "unknown"}`
           const replyText = content.text ?? "";
           const sentMessage = await ctx.reply(replyText);
           const responseMemory = {
-            id: createUniqueUuid(this.runtime, sentMessage.message_id.toString()),
+            id: createUniqueUuid(
+              this.runtime,
+              this.scopedTelegramKey(sentMessage.message_id.toString())
+            ),
             entityId: this.runtime.agentId,
             agentId: this.runtime.agentId,
             roomId,
             content: {
               ...content,
-              inReplyTo: reactionId
+              inReplyTo: reactionId,
+              metadata: { accountId: this.accountId }
+            },
+            metadata: {
+              type: "message",
+              source: "telegram",
+              accountId: this.accountId,
+              provider: "telegram"
             },
             createdAt: sentMessage.date * 1e3
           };
           return [responseMemory];
         } catch (error) {
-          logger2.error({ src: "plugin:telegram", agentId: this.runtime.agentId, error: error instanceof Error ? error.message : String(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 [];
         }
       };
@@ -765,6 +1458,8 @@ Type: ${document.mime_type || "unknown"}`
         message: memory,
         callback,
         source: "telegram",
+        accountId: this.accountId,
+        metadata: { accountId: this.accountId },
         ctx,
         originalMessage: originalMessagePlaceholder,
         // Cast needed due to placeholder
@@ -776,6 +1471,8 @@ Type: ${document.mime_type || "unknown"}`
         message: memory,
         callback,
         source: "telegram",
+        accountId: this.accountId,
+        metadata: { accountId: this.accountId },
         ctx,
         originalMessage: originalMessagePlaceholder,
         // Cast needed due to placeholder
@@ -783,7 +1480,14 @@ Type: ${document.mime_type || "unknown"}`
         originalReaction: reaction.new_reaction[0]
       });
     } catch (error) {
-      logger2.error({ src: "plugin:telegram", agentId: this.runtime.agentId, error: error instanceof Error ? error.message : String(error) }, "Error handling reaction");
+      logger2.error(
+        {
+          src: "plugin:telegram",
+          agentId: this.runtime.agentId,
+          error: error instanceof Error ? error.message : String(error)
+        },
+        "Error handling reaction"
+      );
     }
   }
   /**
@@ -793,7 +1497,7 @@ Type: ${document.mime_type || "unknown"}`
    * @param {number} [replyToMessageId] - Optional message ID to reply to
    * @returns {Promise<Message.TextMessage[]>} The sent messages
    */
-  async sendMessage(chatId, content, replyToMessageId) {
+  async sendMessage(chatId, content, replyToMessageId, messageThreadId) {
     try {
       const ctx = {
         chat: { id: chatId },
@@ -802,14 +1506,25 @@ Type: ${document.mime_type || "unknown"}`
       const sentMessages = await this.sendMessageInChunks(
         ctx,
         content,
-        replyToMessageId
+        replyToMessageId,
+        messageThreadId
+      );
+      if (!sentMessages?.length) {
+        return [];
+      }
+      const roomKey = messageThreadId ? `${chatId.toString()}-${messageThreadId}` : chatId.toString();
+      const roomId = createUniqueUuid(
+        this.runtime,
+        this.scopedTelegramKey(roomKey)
       );
-      if (!sentMessages?.length) return [];
-      const roomId = createUniqueUuid(this.runtime, chatId.toString());
       const memories = [];
+      const contentMetadata = content.metadata && typeof content.metadata === "object" && !Array.isArray(content.metadata) ? content.metadata : {};
       for (const sentMessage of sentMessages) {
         const memory = {
-          id: createUniqueUuid(this.runtime, sentMessage.message_id.toString()),
+          id: createUniqueUuid(
+            this.runtime,
+            this.scopedTelegramKey(sentMessage.message_id.toString())
+          ),
           entityId: this.runtime.agentId,
           agentId: this.runtime.agentId,
           roomId,
@@ -817,11 +1532,34 @@ Type: ${document.mime_type || "unknown"}`
             ...content,
             text: sentMessage.text,
             source: "telegram",
+            metadata: { ...contentMetadata, accountId: this.accountId },
             channelType: getChannelType({
               id: typeof chatId === "string" ? Number.parseInt(chatId, 10) : chatId,
               type: "private"
               // Default to private, will be overridden if in context
-            })
+            }),
+            ...messageThreadId ? {
+              metadata: {
+                ...contentMetadata,
+                accountId: this.accountId,
+                threadId: messageThreadId
+              }
+            } : {}
+          },
+          metadata: {
+            type: "message",
+            source: "telegram",
+            accountId: this.accountId,
+            provider: "telegram",
+            fromBot: true,
+            fromId: this.runtime.agentId,
+            sourceId: this.runtime.agentId,
+            messageIdFull: sentMessage.message_id.toString(),
+            telegram: {
+              chatId: sentMessage.chat.id.toString(),
+              messageId: sentMessage.message_id.toString(),
+              threadId: messageThreadId?.toString()
+            }
           },
           createdAt: sentMessage.date * 1e3
         };
@@ -829,39 +1567,440 @@ Type: ${document.mime_type || "unknown"}`
         memories.push(memory);
       }
       if (memories.length > 0) {
+        const firstMemory = memories[0];
         this.runtime.emitEvent(EventType.MESSAGE_SENT, {
           runtime: this.runtime,
-          message: memories[0],
-          source: "telegram"
+          message: firstMemory,
+          source: "telegram",
+          accountId: this.accountId,
+          metadata: { accountId: this.accountId }
         });
-      }
-      this.runtime.emitEvent(
-        "TELEGRAM_MESSAGE_SENT" /* MESSAGE_SENT */,
-        {
+        const telegramMessageSentPayload = {
           runtime: this.runtime,
           source: "telegram",
+          accountId: this.accountId,
+          metadata: { accountId: this.accountId },
           originalMessages: sentMessages,
           chatId,
-          message: memories[0]
-        }
-      );
+          message: firstMemory
+        };
+        this.runtime.emitEvent(
+          "TELEGRAM_MESSAGE_SENT" /* MESSAGE_SENT */,
+          telegramMessageSentPayload
+        );
+      }
       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");
+      logger2.error(
+        {
+          src: "plugin:telegram",
+          agentId: this.runtime.agentId,
+          chatId,
+          error: error instanceof Error ? error.message : String(error)
+        },
+        "Error sending message to Telegram"
+      );
       return [];
     }
   }
 };
 
+// src/owner-pairing-service.ts
+import { logger as logger3, Service } from "@elizaos/core";
+var TELEGRAM_OWNER_PAIRING_SERVICE_TYPE = "OWNER_PAIRING_TELEGRAM";
+var RATE_LIMIT_MAX_ATTEMPTS = 5;
+var RATE_LIMIT_WINDOW_MS = 6e4;
+async function auditEmit(runtime, action, outcome, metadata) {
+  try {
+    await runtime.emitEvent(
+      ["AUTH_AUDIT"],
+      {
+        runtime,
+        action,
+        outcome,
+        metadata,
+        source: "telegram"
+      }
+    );
+  } catch {
+  }
+}
+var pairAttempts = /* @__PURE__ */ new Map();
+function isRateLimited(userId) {
+  const now = Date.now();
+  const windowStart = now - RATE_LIMIT_WINDOW_MS;
+  const attempts = (pairAttempts.get(userId) ?? []).filter(
+    (ts) => ts > windowStart
+  );
+  pairAttempts.set(userId, attempts);
+  if (attempts.length >= RATE_LIMIT_MAX_ATTEMPTS) {
+    return true;
+  }
+  attempts.push(now);
+  pairAttempts.set(userId, attempts);
+  return false;
+}
+function isValidPairCode(code) {
+  return /^\d{6}$/.test(code.trim());
+}
+function resolveVerifyService(runtime) {
+  try {
+    const svc = runtime.getService("OWNER_BIND_VERIFY");
+    if (svc && typeof svc === "object" && typeof svc.verifyOwnerBindFromConnector === "function") {
+      return svc;
+    }
+  } catch {
+  }
+  return null;
+}
+function resolveDisplayHandle(from) {
+  if (from.username) {
+    return `@${from.username}`;
+  }
+  if (from.first_name) {
+    return from.first_name;
+  }
+  return String(from.id);
+}
+async function handleElizaPairCommand(ctx, runtime) {
+  const from = ctx.from;
+  if (!from) {
+    return;
+  }
+  const userId = String(from.id);
+  const displayHandle = resolveDisplayHandle(from);
+  if (isRateLimited(userId)) {
+    logger3.warn(
+      { src: "plugin:telegram:owner-pairing", userId },
+      "Rate limit hit for /eliza_pair"
+    );
+    await auditEmit(
+      runtime,
+      "auth.owner.pair.telegram.rate_limited",
+      "failure",
+      { externalId: userId }
+    );
+    await ctx.reply(
+      "Too many pairing attempts. Please wait a moment before trying again."
+    );
+    return;
+  }
+  const message = ctx.message;
+  const rawText = message && "text" in message ? message.text : void 0;
+  let code = null;
+  if (typeof rawText === "string") {
+    const parts = rawText.trim().split(/\s+/);
+    if (parts.length >= 2) {
+      code = parts[1] ?? null;
+    }
+  }
+  if (!code?.trim()) {
+    await ctx.reply(
+      "Usage: /eliza\\_pair <code> \u2014 enter the 6-digit code shown in the Eliza dashboard."
+    );
+    return;
+  }
+  code = code.trim();
+  if (!isValidPairCode(code)) {
+    await ctx.reply(
+      "The pairing code must be exactly 6 digits. Check the Eliza dashboard and try again."
+    );
+    return;
+  }
+  const verifySvc = resolveVerifyService(runtime);
+  if (!verifySvc) {
+    logger3.error(
+      { src: "plugin:telegram:owner-pairing", userId },
+      "OWNER_BIND_VERIFY service not available \u2014 cannot complete pairing"
+    );
+    await auditEmit(
+      runtime,
+      "auth.owner.pair.telegram.service_unavailable",
+      "failure",
+      { externalId: userId }
+    );
+    await ctx.reply(
+      "Eliza could not reach the pairing service right now. Please try again in a moment."
+    );
+    return;
+  }
+  let result;
+  try {
+    result = await verifySvc.verifyOwnerBindFromConnector({
+      connector: "telegram",
+      externalId: userId,
+      displayHandle,
+      code
+    });
+  } catch (err) {
+    logger3.error(
+      {
+        src: "plugin:telegram:owner-pairing",
+        userId,
+        error: err instanceof Error ? err.message : String(err)
+      },
+      "verifyOwnerBindFromConnector threw unexpectedly"
+    );
+    await auditEmit(
+      runtime,
+      "auth.owner.pair.telegram.verify_error",
+      "failure",
+      { externalId: userId }
+    );
+    await ctx.reply(
+      "Something went wrong while verifying the pairing code. Please try again."
+    );
+    return;
+  }
+  if (result.success) {
+    logger3.info(
+      { src: "plugin:telegram:owner-pairing", userId, displayHandle },
+      "Owner pairing completed successfully"
+    );
+    await auditEmit(runtime, "auth.owner.pair.telegram.success", "success", {
+      externalId: userId,
+      displayHandle
+    });
+    await ctx.reply("Paired with Eliza. You can now log in via Telegram.");
+  } else {
+    logger3.warn(
+      {
+        src: "plugin:telegram:owner-pairing",
+        userId,
+        backendError: result.error
+      },
+      "Owner pairing rejected by backend"
+    );
+    await auditEmit(runtime, "auth.owner.pair.telegram.failure", "failure", {
+      externalId: userId
+    });
+    await ctx.reply(
+      "Pair code invalid or expired. Check the Eliza dashboard for a fresh code."
+    );
+  }
+}
+var TelegramOwnerPairingServiceImpl = class _TelegramOwnerPairingServiceImpl extends Service {
+  static serviceType = TELEGRAM_OWNER_PAIRING_SERVICE_TYPE;
+  capabilityDescription = "Handles Telegram-side owner pairing (command code verification) and DM login-link delivery for Eliza remote auth";
+  static async start(runtime) {
+    const service = new _TelegramOwnerPairingServiceImpl(runtime);
+    if (resolveVerifyService(runtime)) {
+      service.registerPairCommand(runtime);
+      logger3.info(
+        {
+          src: "plugin:telegram:owner-pairing",
+          agentId: runtime.agentId
+        },
+        "TelegramOwnerPairingService started; /eliza_pair command registered"
+      );
+    } else {
+      logger3.info(
+        {
+          src: "plugin:telegram:owner-pairing",
+          agentId: runtime.agentId
+        },
+        "TelegramOwnerPairingService started without /eliza_pair because OWNER_BIND_VERIFY is not registered"
+      );
+    }
+    return service;
+  }
+  async stop() {
+    pairAttempts.clear();
+  }
+  /**
+   * Registers the /eliza_pair command with the active Telegraf bot instance
+   * by looking up the TelegramService from the runtime service registry.
+   * Called during `start`; it is safe to call this before or after the bot
+   * has finished initialising because Telegraf accepts handler registration
+   * at any point before `launch()`.
+   *
+   * If the TelegramService is unavailable, the command is not registered.
+   */
+  registerPairCommand(runtime) {
+    const telegramSvc = runtime.getService(TELEGRAM_SERVICE_NAME);
+    if (!telegramSvc || typeof telegramSvc !== "object") {
+      logger3.warn(
+        { src: "plugin:telegram:owner-pairing", agentId: runtime.agentId },
+        "TelegramService unavailable during owner-pairing start; /eliza_pair command not registered"
+      );
+      return;
+    }
+    const bot = "bot" in telegramSvc ? telegramSvc.bot : null;
+    if (!bot || typeof bot.command !== "function") {
+      logger3.warn(
+        { src: "plugin:telegram:owner-pairing", agentId: runtime.agentId },
+        "Telegraf bot instance not available \u2014 /eliza_pair will not be registered"
+      );
+      return;
+    }
+    const telegrafBot = bot;
+    telegrafBot.command("eliza_pair", async (ctx) => {
+      await handleElizaPairCommand(ctx, runtime);
+    });
+    logger3.debug(
+      { src: "plugin:telegram:owner-pairing", agentId: runtime.agentId },
+      "/eliza_pair command registered with Telegraf bot"
+    );
+  }
+  async sendOwnerLoginDmLink(params) {
+    const { externalId, link } = params;
+    const telegramSvc = this.runtime.getService(
+      TELEGRAM_SERVICE_NAME
+    );
+    const bot = telegramSvc && typeof telegramSvc === "object" && "bot" in telegramSvc ? telegramSvc.bot : null;
+    if (!bot || typeof bot.telegram !== "object") {
+      throw new Error(
+        "Telegram bot is not available \u2014 cannot send DM login link"
+      );
+    }
+    const telegrafBot = bot;
+    const chatId = Number(externalId);
+    if (!Number.isFinite(chatId) || chatId <= 0) {
+      throw new Error(
+        `Invalid Telegram externalId "${externalId}" \u2014 must be a positive numeric user ID`
+      );
+    }
+    const message = `Click to log in to Eliza: ${link}
+
+_This link expires in 5 minutes. Do not share it._`;
+    try {
+      await telegrafBot.telegram.sendMessage(chatId, message, {
+        parse_mode: "Markdown"
+      });
+      logger3.info(
+        { src: "plugin:telegram:owner-pairing", externalId },
+        "Login DM link sent"
+      );
+    } catch (err) {
+      throw new Error(
+        `Failed to send DM login link to Telegram user ${externalId}: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+};
+
 // src/service.ts
-var TelegramService = class _TelegramService extends Service {
+import {
+  ChannelType as ChannelType2,
+  createUniqueUuid as createUniqueUuid2,
+  EventType as EventType2,
+  logger as logger4,
+  Role,
+  Service as Service2
+} from "@elizaos/core";
+import { Telegraf } from "telegraf";
+var CANONICAL_OWNER_SETTING_KEYS = ["ELIZA_ADMIN_ENTITY_ID"];
+var TELEGRAM_CONNECTOR_CONTEXTS = ["social", "connectors"];
+var TELEGRAM_CONNECTOR_CAPABILITIES = [
+  "send_message",
+  "resolve_targets",
+  "list_rooms",
+  "chat_context",
+  "user_context"
+];
+var TELEGRAM_CHAT_ID_PATTERN = /^-?\d+$/;
+var TELEGRAM_THREADED_CHANNEL_PATTERN = /^(-?\d+)-(\d+)$/;
+function normalizeConnectorLimit(limit, fallback = 50) {
+  if (!Number.isFinite(limit) || !limit || limit <= 0) {
+    return fallback;
+  }
+  return Math.min(Math.floor(limit), 200);
+}
+function filterMemoriesByQuery(memories, query, limit) {
+  const normalized = query.trim().toLowerCase();
+  if (!normalized) {
+    return memories.slice(0, limit);
+  }
+  return memories.filter((memory) => {
+    const text = typeof memory.content?.text === "string" ? memory.content.text : "";
+    return text.toLowerCase().includes(normalized);
+  }).slice(0, limit);
+}
+var ACTIVE_TELEGRAM_POLLERS = /* @__PURE__ */ new Map();
+function getCanonicalOwnerId(runtime) {
+  for (const key of CANONICAL_OWNER_SETTING_KEYS) {
+    const value = runtime.getSetting(key);
+    if (typeof value !== "string") {
+      continue;
+    }
+    const trimmed = value.trim();
+    if (trimmed.length > 0) {
+      return trimmed;
+    }
+  }
+  return null;
+}
+function getTelegramChatDisplayName(chat, fallback) {
+  if (!chat) {
+    return fallback;
+  }
+  if ("title" in chat && typeof chat.title === "string" && chat.title.trim()) {
+    return chat.title;
+  }
+  if ("first_name" in chat && typeof chat.first_name === "string" && chat.first_name.trim()) {
+    return chat.first_name;
+  }
+  if ("username" in chat && typeof chat.username === "string" && chat.username.trim()) {
+    return chat.username;
+  }
+  return fallback;
+}
+function normalizeTelegramConnectorQuery(value) {
+  return value.trim().replace(/^@/, "").toLowerCase();
+}
+function scoreTelegramConnectorMatch(query, id, labels) {
+  if (!query) {
+    return 0.45;
+  }
+  if (id.toLowerCase() === query) {
+    return 1;
+  }
+  let bestScore = 0;
+  for (const label of labels) {
+    const normalized = label?.trim().replace(/^@/, "").toLowerCase();
+    if (!normalized) {
+      continue;
+    }
+    if (normalized === query) {
+      bestScore = Math.max(bestScore, 0.95);
+    } else if (normalized.startsWith(query)) {
+      bestScore = Math.max(bestScore, 0.85);
+    } else if (normalized.includes(query)) {
+      bestScore = Math.max(bestScore, 0.7);
+    }
+  }
+  return bestScore;
+}
+function parseTelegramTargetParts(channelId, explicitThreadId) {
+  const explicitThreadNumber = explicitThreadId && /^\d+$/.test(explicitThreadId) ? Number.parseInt(explicitThreadId, 10) : void 0;
+  const threadedMatch = channelId.match(TELEGRAM_THREADED_CHANNEL_PATTERN);
+  if (threadedMatch) {
+    return {
+      chatId: threadedMatch[1],
+      threadId: explicitThreadNumber ?? Number.parseInt(threadedMatch[2], 10)
+    };
+  }
+  return { chatId: channelId, threadId: explicitThreadNumber };
+}
+function telegramChatKind(chat) {
+  if (chat.type === "private") {
+    return "user";
+  }
+  if (chat.type === "channel") {
+    return "channel";
+  }
+  return "group";
+}
+var TelegramService = class _TelegramService extends Service2 {
   static serviceType = TELEGRAM_SERVICE_NAME;
   capabilityDescription = "The agent is able to send and receive messages on telegram";
-  bot;
-  messageManager;
-  options;
+  bot = null;
+  messageManager = null;
   knownChats = /* @__PURE__ */ new Map();
   syncedEntityIds = /* @__PURE__ */ new Set();
+  botToken;
+  defaultAccountId = DEFAULT_ACCOUNT_ID;
+  accountStates = /* @__PURE__ */ new Map();
   /**
    * Constructor for TelegramService class.
    * @param {IAgentRuntime} runtime - The runtime object for the agent.
@@ -871,31 +2010,134 @@ var TelegramService = class _TelegramService extends Service {
     if (!runtime) {
       this.bot = null;
       this.messageManager = null;
+      this.botToken = null;
       return;
     }
-    logger3.debug({ src: "plugin:telegram", agentId: runtime.agentId }, "Constructing TelegramService");
-    const botToken = runtime.getSetting("TELEGRAM_BOT_TOKEN");
-    if (!botToken || botToken.trim() === "") {
-      logger3.warn({ src: "plugin:telegram", agentId: runtime.agentId }, "Bot token not provided, Telegram functionality unavailable");
+    logger4.debug(
+      { src: "plugin:telegram", agentId: runtime.agentId },
+      "Constructing TelegramService"
+    );
+    this.defaultAccountId = resolveDefaultTelegramAccountId(runtime);
+    const account = resolveTelegramAccount(runtime, this.defaultAccountId);
+    this.botToken = account.botToken ?? null;
+    if (!account.botToken) {
+      logger4.warn(
+        {
+          src: "plugin:telegram",
+          agentId: runtime.agentId,
+          accountId: account.accountId
+        },
+        "Bot token not provided, Telegram functionality unavailable"
+      );
       this.bot = null;
       this.messageManager = null;
       return;
     }
-    this.options = {
-      telegram: {
-        apiRoot: runtime.getSetting("TELEGRAM_API_ROOT") || process.env.TELEGRAM_API_ROOT || "https://api.telegram.org"
-      }
-    };
     try {
-      this.bot = new Telegraf(botToken, this.options);
-      this.messageManager = new MessageManager(this.bot, this.runtime);
-      logger3.debug({ src: "plugin:telegram", agentId: runtime.agentId }, "TelegramService constructor completed");
+      const state = this.createAccountRuntime(account);
+      this.setDefaultAccountState(state);
+      logger4.debug(
+        {
+          src: "plugin:telegram",
+          agentId: runtime.agentId,
+          accountId: account.accountId
+        },
+        "TelegramService constructor completed"
+      );
     } catch (error) {
-      logger3.error({ src: "plugin:telegram", agentId: runtime.agentId, error: error instanceof Error ? error.message : String(error) }, "Failed to initialize Telegram bot");
+      logger4.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;
     }
   }
+  createAccountRuntime(account) {
+    if (!account.botToken) {
+      throw new Error(`Telegram account ${account.accountId} has no bot token`);
+    }
+    const bot = new Telegraf(account.botToken, {
+      telegram: { apiRoot: account.apiRoot }
+    });
+    const messageManager = new MessageManager(
+      bot,
+      this.runtime,
+      account.accountId
+    );
+    return {
+      accountId: account.accountId,
+      account,
+      bot,
+      messageManager
+    };
+  }
+  setDefaultAccountState(state) {
+    this.accountStates.set(state.accountId, state);
+    if (state.accountId === this.defaultAccountId || !this.bot) {
+      this.bot = state.bot;
+      this.messageManager = state.messageManager;
+      this.botToken = state.account.botToken ?? null;
+    }
+  }
+  getDefaultAccountState() {
+    if (!(this.accountStates instanceof Map) || this.accountStates.size === 0) {
+      return null;
+    }
+    return this.accountStates.get(this.defaultAccountId) ?? this.accountStates.values().next().value ?? null;
+  }
+  getAccountState(accountId) {
+    if (!(this.accountStates instanceof Map) || this.accountStates.size === 0) {
+      return null;
+    }
+    if (accountId) {
+      return this.accountStates.get(normalizeTelegramAccountId(accountId)) ?? null;
+    }
+    return this.getDefaultAccountState();
+  }
+  getAccountIds() {
+    if (this.accountStates instanceof Map && this.accountStates.size > 0) {
+      return Array.from(this.accountStates.keys());
+    }
+    return [normalizeTelegramAccountId(this.defaultAccountId)];
+  }
+  resolveAccountIdFromContext(context, target) {
+    const scopedTarget = target;
+    const scopedContext = context;
+    return scopedTarget?.accountId ?? scopedContext?.target?.accountId ?? scopedContext?.accountId ?? scopedContext?.account?.accountId ?? void 0;
+  }
+  async resolveAccountIdForTarget(runtime, target, fallback) {
+    const direct = target?.accountId ?? fallback?.accountId;
+    if (direct) {
+      return normalizeTelegramAccountId(direct);
+    }
+    const roomId = target?.roomId ?? fallback?.roomId;
+    if (roomId && typeof runtime.getRoom === "function") {
+      const room = await runtime.getRoom(roomId);
+      const metadata = room?.metadata;
+      if (typeof metadata?.accountId === "string" && metadata.accountId.trim()) {
+        return normalizeTelegramAccountId(metadata.accountId);
+      }
+      const telegram = metadata?.telegram && typeof metadata.telegram === "object" ? metadata.telegram : void 0;
+      if (typeof telegram?.accountId === "string" && telegram.accountId.trim()) {
+        return normalizeTelegramAccountId(telegram.accountId);
+      }
+    }
+    return normalizeTelegramAccountId(this.defaultAccountId);
+  }
+  scopedTelegramKey(key, accountId) {
+    const normalized = normalizeTelegramAccountId(
+      accountId ?? this.defaultAccountId
+    );
+    return normalized === DEFAULT_ACCOUNT_ID ? key : `${normalized}:${key}`;
+  }
+  knownChatKeyMatchesAccount(key, chat, accountId) {
+    return key === this.scopedTelegramKey(chat.id.toString(), accountId);
+  }
   /**
    * Starts the Telegram service for the given runtime.
    *
@@ -904,34 +2146,88 @@ var TelegramService = class _TelegramService extends Service {
    */
   static async start(runtime) {
     const service = new _TelegramService(runtime);
+    for (const account of listEnabledTelegramAccounts(runtime)) {
+      if (!service.getAccountState(account.accountId)) {
+        service.setDefaultAccountState(service.createAccountRuntime(account));
+      }
+    }
     if (!service.bot) {
-      logger3.warn({ src: "plugin:telegram", agentId: runtime.agentId }, "Service started without bot functionality");
+      logger4.warn(
+        { src: "plugin:telegram", agentId: runtime.agentId },
+        "Service started without bot functionality"
+      );
       return service;
     }
     const maxRetries = 5;
-    let retryCount = 0;
-    let lastError = null;
-    while (retryCount < maxRetries) {
-      try {
-        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({ 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({ src: "plugin:telegram", agentId: runtime.agentId, delaySeconds: delay / 1e3 }, "Retrying initialization");
-          await new Promise((resolve) => setTimeout(resolve, delay));
+    for (const state of service.accountStates.values()) {
+      let retryCount = 0;
+      let lastError = null;
+      while (retryCount < maxRetries) {
+        try {
+          logger4.info(
+            {
+              src: "plugin:telegram",
+              agentId: runtime.agentId,
+              agentName: runtime.character.name,
+              accountId: state.accountId
+            },
+            "Starting Telegram bot"
+          );
+          await service.initializeBot(state);
+          service.setupMiddlewares(state);
+          service.setupMessageHandlers(state);
+          await state.bot.telegram.getMe();
+          logger4.success(
+            {
+              src: "plugin:telegram",
+              agentId: runtime.agentId,
+              agentName: runtime.character.name,
+              accountId: state.accountId
+            },
+            "Telegram bot started successfully"
+          );
+          break;
+        } catch (error) {
+          lastError = error instanceof Error ? error : new Error(String(error));
+          logger4.error(
+            {
+              src: "plugin:telegram",
+              agentId: runtime.agentId,
+              accountId: state.accountId,
+              attempt: retryCount + 1,
+              error: lastError.message
+            },
+            "Initialization attempt failed"
+          );
+          retryCount++;
+          if (retryCount < maxRetries) {
+            const delay = 2 ** retryCount * 1e3;
+            logger4.info(
+              {
+                src: "plugin:telegram",
+                agentId: runtime.agentId,
+                accountId: state.accountId,
+                delaySeconds: delay / 1e3
+              },
+              "Retrying initialization"
+            );
+            await new Promise((resolve) => setTimeout(resolve, delay));
+          }
         }
       }
+      if (retryCount >= maxRetries) {
+        logger4.error(
+          {
+            src: "plugin:telegram",
+            agentId: runtime.agentId,
+            accountId: state.accountId,
+            maxRetries,
+            error: lastError?.message
+          },
+          "Initialization failed after all attempts"
+        );
+      }
     }
-    logger3.error({ src: "plugin:telegram", agentId: runtime.agentId, maxRetries, error: lastError?.message }, "Initialization failed after all attempts");
     return service;
   }
   /**
@@ -939,7 +2235,7 @@ var TelegramService = class _TelegramService extends Service {
    * @param {IAgentRuntime} runtime - The agent runtime to stop
    */
   static async stop(runtime) {
-    const tgClient = runtime.getService(TELEGRAM_SERVICE_NAME);
+    const tgClient = await runtime.getService(TELEGRAM_SERVICE_NAME);
     if (tgClient) {
       await tgClient.stop();
     }
@@ -950,31 +2246,109 @@ var TelegramService = class _TelegramService extends Service {
    * @returns A Promise that resolves once the bot has stopped.
    */
   async stop() {
-    this.bot?.stop();
+    const states = this.accountStates instanceof Map ? Array.from(this.accountStates.values()) : [];
+    if (states.length > 0) {
+      for (const state of states) {
+        state.bot.stop("service-stop");
+        const token = state.account.botToken;
+        if (token) {
+          const active = ACTIVE_TELEGRAM_POLLERS.get(token);
+          if (active?.bot === state.bot) {
+            ACTIVE_TELEGRAM_POLLERS.delete(token);
+          }
+        }
+      }
+      return;
+    }
+    const bot = this.bot;
+    if (bot) {
+      bot.stop("service-stop");
+      if (this.botToken) {
+        const active = ACTIVE_TELEGRAM_POLLERS.get(this.botToken);
+        if (active?.bot === bot) {
+          ACTIVE_TELEGRAM_POLLERS.delete(this.botToken);
+        }
+      }
+    }
   }
   /**
    * Initializes the Telegram bot by launching it, getting bot info, and setting up message manager.
    * @returns {Promise<void>} A Promise that resolves when the initialization is complete.
    */
-  async initializeBot() {
-    this.bot?.start((ctx) => {
+  async initializeBot(state) {
+    const activeState = state ?? this.getDefaultAccountState();
+    const bot = activeState?.bot ?? this.bot;
+    if (!bot) {
+      throw new Error("Telegram bot is not initialized");
+    }
+    const botToken = activeState?.account.botToken ?? this.botToken;
+    const accountId = activeState?.accountId ?? this.defaultAccountId;
+    if (botToken) {
+      const active = ACTIVE_TELEGRAM_POLLERS.get(botToken);
+      if (active && active.bot !== bot) {
+        logger4.warn(
+          {
+            src: "plugin:telegram",
+            agentId: this.runtime.agentId,
+            accountId,
+            previousAgentId: active.agentId
+          },
+          "Stopping existing Telegram poller before launching a new one"
+        );
+        try {
+          active.bot.stop("replaced-by-new-runtime");
+        } catch (error) {
+          logger4.warn(
+            {
+              src: "plugin:telegram",
+              agentId: this.runtime.agentId,
+              accountId,
+              error: error instanceof Error ? error.message : String(error)
+            },
+            "Failed to stop previous Telegram poller cleanly"
+          );
+        }
+        ACTIVE_TELEGRAM_POLLERS.delete(botToken);
+        await new Promise((resolve) => setTimeout(resolve, 300));
+      }
+    }
+    bot.start((ctx) => {
+      const slashStartPayload = {
+        ctx,
+        runtime: this.runtime,
+        source: "telegram",
+        accountId,
+        metadata: { accountId }
+      };
       this.runtime.emitEvent(
         "TELEGRAM_SLASH_START" /* SLASH_START */,
-        {
-          ctx,
-          runtime: this.runtime,
-          source: "telegram"
-        }
+        slashStartPayload
       );
     });
-    this.bot?.launch({
+    await bot.launch({
       dropPendingUpdates: true,
       allowedUpdates: ["message", "message_reaction"]
     });
-    const botInfo = await this.bot.telegram.getMe();
-    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"));
+    if (botToken) {
+      ACTIVE_TELEGRAM_POLLERS.set(botToken, {
+        bot,
+        agentId: this.runtime.agentId,
+        accountId
+      });
+    }
+    const botInfo = await bot.telegram.getMe();
+    logger4.debug(
+      {
+        src: "plugin:telegram",
+        agentId: this.runtime.agentId,
+        accountId,
+        botId: botInfo.id,
+        botUsername: botInfo.username
+      },
+      "Bot info retrieved"
+    );
+    process.once("SIGINT", () => bot.stop("SIGINT"));
+    process.once("SIGTERM", () => bot.stop("SIGTERM"));
   }
   /**
    * Sets up the middleware chain for preprocessing messages before they reach handlers.
@@ -991,9 +2365,11 @@ var TelegramService = class _TelegramService extends Service {
    *
    * @private
    */
-  setupMiddlewares() {
-    this.bot?.use(this.authorizationMiddleware.bind(this));
-    this.bot?.use(this.chatAndEntityMiddleware.bind(this));
+  setupMiddlewares(state) {
+    const bot = state?.bot ?? this.bot;
+    const accountId = state?.accountId ?? this.defaultAccountId;
+    bot?.use((ctx, next) => this.authorizationMiddleware(ctx, next, accountId));
+    bot?.use((ctx, next) => this.chatAndEntityMiddleware(ctx, next, accountId));
   }
   /**
    * Authorization middleware - checks if chat is allowed to interact with the bot
@@ -1004,9 +2380,17 @@ var TelegramService = class _TelegramService extends Service {
    * @returns {Promise<void>}
    * @private
    */
-  async authorizationMiddleware(ctx, next) {
-    if (!await this.isGroupAuthorized(ctx)) {
-      logger3.debug({ src: "plugin:telegram", agentId: this.runtime.agentId, chatId: ctx.chat?.id }, "Chat not authorized, skipping");
+  async authorizationMiddleware(ctx, next, accountId = this.defaultAccountId) {
+    if (!await this.isGroupAuthorized(ctx, accountId)) {
+      logger4.debug(
+        {
+          src: "plugin:telegram",
+          agentId: this.runtime.agentId,
+          accountId,
+          chatId: ctx.chat?.id
+        },
+        "Chat not authorized, skipping"
+      );
       return;
     }
     await next();
@@ -1021,14 +2405,16 @@ var TelegramService = class _TelegramService extends Service {
    * @returns {Promise<void>}
    * @private
    */
-  async chatAndEntityMiddleware(ctx, next) {
-    if (!ctx.chat) return next();
+  async chatAndEntityMiddleware(ctx, next, accountId = this.defaultAccountId) {
+    if (!ctx.chat) {
+      return next();
+    }
     const chatId = ctx.chat.id.toString();
-    if (!this.knownChats.has(chatId)) {
-      await this.handleNewChat(ctx);
+    if (!this.knownChats.has(this.scopedTelegramKey(chatId, accountId))) {
+      await this.handleNewChat(ctx, accountId);
       return next();
     }
-    await this.processExistingChat(ctx);
+    await this.processExistingChat(ctx, accountId);
     await next();
   }
   /**
@@ -1039,18 +2425,29 @@ var TelegramService = class _TelegramService extends Service {
    * @returns {Promise<void>}
    * @private
    */
-  async processExistingChat(ctx) {
-    if (!ctx.chat) return;
+  async processExistingChat(ctx, accountId = this.defaultAccountId) {
+    if (!ctx.chat) {
+      return;
+    }
     const chat = ctx.chat;
     if (chat.type === "supergroup" && chat.is_forum && ctx.message?.message_thread_id) {
       try {
-        await this.handleForumTopic(ctx);
+        await this.handleForumTopic(ctx, accountId);
       } catch (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");
+        logger4.error(
+          {
+            src: "plugin:telegram",
+            agentId: this.runtime.agentId,
+            accountId,
+            chatId: chat.id,
+            error: error instanceof Error ? error.message : String(error)
+          },
+          "Error handling forum topic"
+        );
       }
     }
     if (ctx.from && ctx.chat.type !== "private") {
-      await this.syncEntity(ctx);
+      await this.syncEntity(ctx, accountId);
     }
   }
   /**
@@ -1059,19 +2456,38 @@ var TelegramService = class _TelegramService extends Service {
    *
    * @private
    */
-  setupMessageHandlers() {
-    this.bot?.on("message", async (ctx) => {
+  setupMessageHandlers(state) {
+    const bot = state?.bot ?? this.bot;
+    const messageManager = state?.messageManager ?? this.messageManager;
+    const accountId = state?.accountId ?? this.defaultAccountId;
+    bot?.on("message", async (ctx) => {
       try {
-        await this.messageManager.handleMessage(ctx);
+        await messageManager?.handleMessage(ctx);
       } catch (error) {
-        logger3.error({ src: "plugin:telegram", agentId: this.runtime.agentId, error: error instanceof Error ? error.message : String(error) }, "Error handling message");
+        logger4.error(
+          {
+            src: "plugin:telegram",
+            agentId: this.runtime.agentId,
+            accountId,
+            error: error instanceof Error ? error.message : String(error)
+          },
+          "Error handling message"
+        );
       }
     });
-    this.bot?.on("message_reaction", async (ctx) => {
+    bot?.on("message_reaction", async (ctx) => {
       try {
-        await this.messageManager.handleReaction(ctx);
+        await messageManager?.handleReaction(ctx);
       } catch (error) {
-        logger3.error({ src: "plugin:telegram", agentId: this.runtime.agentId, error: error instanceof Error ? error.message : String(error) }, "Error handling reaction");
+        logger4.error(
+          {
+            src: "plugin:telegram",
+            agentId: this.runtime.agentId,
+            accountId,
+            error: error instanceof Error ? error.message : String(error)
+          },
+          "Error handling reaction"
+        );
       }
     });
   }
@@ -1080,9 +2496,15 @@ var TelegramService = class _TelegramService extends Service {
    * @param {Context} ctx - The context of the incoming update.
    * @returns {Promise<boolean>} A Promise that resolves with a boolean indicating if the group is authorized.
    */
-  async isGroupAuthorized(ctx) {
+  async isGroupAuthorized(ctx, accountId = this.defaultAccountId) {
     const chatId = ctx.chat?.id.toString();
-    if (!chatId) return false;
+    if (!chatId) {
+      return false;
+    }
+    const accountAllowedChats = this.getAccountState(accountId)?.account.config.allowedChats;
+    if (accountAllowedChats?.length) {
+      return accountAllowedChats.includes(chatId);
+    }
     const allowedChats = this.runtime.getSetting("TELEGRAM_ALLOWED_CHATS");
     if (!allowedChats) {
       return true;
@@ -1091,7 +2513,15 @@ var TelegramService = class _TelegramService extends Service {
       const allowedChatsList = JSON.parse(allowedChats);
       return allowedChatsList.includes(chatId);
     } catch (error) {
-      logger3.error({ src: "plugin:telegram", agentId: this.runtime.agentId, error: error instanceof Error ? error.message : String(error) }, "Error parsing TELEGRAM_ALLOWED_CHATS");
+      logger4.error(
+        {
+          src: "plugin:telegram",
+          agentId: this.runtime.agentId,
+          accountId,
+          error: error instanceof Error ? error.message : String(error)
+        },
+        "Error parsing TELEGRAM_ALLOWED_CHATS"
+      );
       return false;
     }
   }
@@ -1106,18 +2536,26 @@ var TelegramService = class _TelegramService extends Service {
    * @returns {Promise<void>}
    * @private
    */
-  async syncEntity(ctx) {
-    if (!ctx.chat) return;
+  async syncEntity(ctx, accountId = this.defaultAccountId) {
+    if (!ctx.chat) {
+      return;
+    }
     const chat = ctx.chat;
     const chatId = chat.id.toString();
-    const worldId = createUniqueUuid2(this.runtime, chatId);
+    const worldId = createUniqueUuid2(
+      this.runtime,
+      this.scopedTelegramKey(chatId, accountId)
+    );
     const roomId = createUniqueUuid2(
       this.runtime,
-      ctx.message?.message_thread_id ? `${ctx.chat.id}-${ctx.message.message_thread_id}` : ctx.chat.id.toString()
+      this.scopedTelegramKey(
+        ctx.message?.message_thread_id ? `${ctx.chat.id}-${ctx.message.message_thread_id}` : ctx.chat.id.toString(),
+        accountId
+      )
     );
-    await this.syncMessageSender(ctx, worldId, roomId, chatId);
-    await this.syncNewChatMember(ctx, worldId, roomId, chatId);
-    await this.syncLeftChatMember(ctx);
+    await this.syncMessageSender(ctx, worldId, roomId, chatId, accountId);
+    await this.syncNewChatMember(ctx, worldId, roomId, chatId, accountId);
+    await this.syncLeftChatMember(ctx, accountId);
   }
   /**
    * Synchronizes the message sender entity with the runtime system.
@@ -1130,13 +2568,20 @@ var TelegramService = class _TelegramService extends Service {
    * @returns {Promise<void>}
    * @private
    */
-  async syncMessageSender(ctx, worldId, roomId, chatId) {
-    if (ctx.from && !this.syncedEntityIds.has(ctx.from.id.toString())) {
+  async syncMessageSender(ctx, worldId, roomId, chatId, accountId = this.defaultAccountId) {
+    if (ctx.from) {
       const telegramId = ctx.from.id.toString();
-      const entityId = createUniqueUuid2(this.runtime, telegramId);
+      const entityId = createUniqueUuid2(
+        this.runtime,
+        this.scopedTelegramKey(telegramId, accountId)
+      );
+      if (this.syncedEntityIds.has(entityId)) {
+        return;
+      }
       await this.runtime.ensureConnection({
         entityId,
         roomId,
+        roomName: getTelegramChatDisplayName(ctx.chat, chatId),
         userName: ctx.from.username,
         userId: telegramId,
         name: ctx.from.first_name || ctx.from.username || "Unknown User",
@@ -1159,38 +2604,48 @@ var TelegramService = class _TelegramService extends Service {
    * @returns {Promise<void>}
    * @private
    */
-  async syncNewChatMember(ctx, worldId, roomId, chatId) {
-    if (ctx.message && "new_chat_member" in ctx.message) {
-      const newMember = ctx.message.new_chat_member;
-      const telegramId = newMember.id.toString();
-      const entityId = createUniqueUuid2(this.runtime, telegramId);
-      if (this.syncedEntityIds.has(telegramId)) return;
-      await this.runtime.ensureConnection({
-        entityId,
-        roomId,
-        userName: newMember.username,
-        userId: telegramId,
-        name: newMember.first_name || newMember.username || "Unknown User",
-        source: "telegram",
-        channelId: chatId,
-        type: ChannelType2.GROUP,
-        worldId
-      });
-      this.syncedEntityIds.add(entityId);
-      this.runtime.emitEvent(
-        "TELEGRAM_ENTITY_JOINED" /* ENTITY_JOINED */,
-        {
+  async syncNewChatMember(ctx, worldId, roomId, chatId, accountId = this.defaultAccountId) {
+    if (ctx.message && "new_chat_members" in ctx.message) {
+      for (const newMember of ctx.message.new_chat_members) {
+        const telegramId = newMember.id.toString();
+        const entityId = createUniqueUuid2(
+          this.runtime,
+          this.scopedTelegramKey(telegramId, accountId)
+        );
+        if (this.syncedEntityIds.has(entityId)) {
+          continue;
+        }
+        await this.runtime.ensureConnection({
+          entityId,
+          roomId,
+          roomName: getTelegramChatDisplayName(ctx.chat, chatId),
+          userName: newMember.username,
+          userId: telegramId,
+          name: newMember.first_name || newMember.username || "Unknown User",
+          source: "telegram",
+          channelId: chatId,
+          type: ChannelType2.GROUP,
+          worldId
+        });
+        this.syncedEntityIds.add(entityId);
+        const entityJoinedPayload = {
           runtime: this.runtime,
           entityId,
           worldId,
           source: "telegram",
+          accountId,
+          metadata: { accountId },
           telegramUser: {
             id: newMember.id,
             username: newMember.username,
             first_name: newMember.first_name
           }
-        }
-      );
+        };
+        this.runtime.emitEvent(
+          "TELEGRAM_ENTITY_JOINED" /* ENTITY_JOINED */,
+          entityJoinedPayload
+        );
+      }
     }
   }
   /**
@@ -1200,15 +2655,19 @@ var TelegramService = class _TelegramService extends Service {
    * @returns {Promise<void>}
    * @private
    */
-  async syncLeftChatMember(ctx) {
+  async syncLeftChatMember(ctx, accountId = this.defaultAccountId) {
     if (ctx.message && "left_chat_member" in ctx.message) {
       const leftMember = ctx.message.left_chat_member;
       const telegramId = leftMember.id.toString();
-      const entityId = createUniqueUuid2(this.runtime, telegramId);
+      const entityId = createUniqueUuid2(
+        this.runtime,
+        this.scopedTelegramKey(telegramId, accountId)
+      );
       const existingEntity = await this.runtime.getEntityById(entityId);
       if (existingEntity) {
         existingEntity.metadata = {
           ...existingEntity.metadata,
+          accountId,
           status: "INACTIVE",
           leftAt: Date.now()
         };
@@ -1224,28 +2683,43 @@ var TelegramService = class _TelegramService extends Service {
    * @returns {Promise<void>}
    * @private
    */
-  async handleForumTopic(ctx) {
-    if (!ctx.chat || !ctx.message?.message_thread_id) return;
+  async handleForumTopic(ctx, accountId = this.defaultAccountId) {
+    if (!ctx.chat || !ctx.message?.message_thread_id) {
+      return;
+    }
     const chat = ctx.chat;
     const chatId = chat.id.toString();
-    const worldId = createUniqueUuid2(this.runtime, chatId);
-    const room = await this.buildForumTopicRoom(ctx, worldId);
-    if (!room) return;
+    const worldId = createUniqueUuid2(
+      this.runtime,
+      this.scopedTelegramKey(chatId, accountId)
+    );
+    const room = await this.buildForumTopicRoom(ctx, worldId, accountId);
+    if (!room) {
+      return;
+    }
     await this.runtime.ensureRoomExists(room);
   }
   /**
    * Builds entity for message sender
    */
-  buildMsgSenderEntity(from) {
-    if (!from) return null;
-    const userId = createUniqueUuid2(this.runtime, from.id.toString());
+  buildMsgSenderEntity(from, accountId = this.defaultAccountId) {
+    if (!from) {
+      return null;
+    }
+    const userId = createUniqueUuid2(
+      this.runtime,
+      this.scopedTelegramKey(from.id.toString(), accountId)
+    );
     const telegramId = from.id.toString();
     return {
       id: userId,
       agentId: this.runtime.agentId,
       names: [from.first_name || from.username || "Unknown User"],
       metadata: {
+        source: "telegram",
+        accountId,
         telegram: {
+          accountId,
           id: telegramId,
           username: from.username,
           name: from.first_name || from.username || "Unknown User"
@@ -1262,18 +2736,26 @@ var TelegramService = class _TelegramService extends Service {
    * @returns {Promise<void>}
    * @private
    */
-  async handleNewChat(ctx) {
-    if (!ctx.chat) return;
+  async handleNewChat(ctx, accountId = this.defaultAccountId) {
+    if (!ctx.chat) {
+      return;
+    }
     const chat = ctx.chat;
     const chatId = chat.id.toString();
-    this.knownChats.set(chatId, chat);
+    this.knownChats.set(this.scopedTelegramKey(chatId, accountId), chat);
     const { chatTitle, channelType } = this.getChatTypeInfo(chat);
-    const worldId = createUniqueUuid2(this.runtime, chatId);
+    const worldId = createUniqueUuid2(
+      this.runtime,
+      this.scopedTelegramKey(chatId, accountId)
+    );
     const existingWorld = await this.runtime.getWorld(worldId);
     if (existingWorld) {
       return;
     }
-    const userId = ctx.from ? createUniqueUuid2(this.runtime, ctx.from.id.toString()) : null;
+    const userId = ctx.from ? createUniqueUuid2(
+      this.runtime,
+      this.scopedTelegramKey(ctx.from.id.toString(), accountId)
+    ) : null;
     let admins = [];
     let owner = null;
     if (chat.type === "group" || chat.type === "supergroup" || chat.type === "channel") {
@@ -1285,20 +2767,33 @@ var TelegramService = class _TelegramService extends Service {
         );
         owner = foundOwner || null;
       } catch (error) {
-        logger3.warn({ src: "plugin:telegram", agentId: this.runtime.agentId, chatId, error: error instanceof Error ? error.message : String(error) }, "Could not get chat administrators");
+        logger4.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;
-    if (owner) {
-      ownerId = createUniqueUuid2(this.runtime, String(owner.user.id));
+    const canonicalOwnerId = getCanonicalOwnerId(this.runtime);
+    let ownerId = canonicalOwnerId ?? userId;
+    if (!canonicalOwnerId && owner) {
+      ownerId = createUniqueUuid2(
+        this.runtime,
+        this.scopedTelegramKey(String(owner.user.id), accountId)
+      );
     }
     const world = {
       id: worldId,
       name: chatTitle,
       agentId: this.runtime.agentId,
-      serverId: chatId,
+      messageServerId: chatId,
       metadata: {
         source: "telegram",
+        accountId,
         ...ownerId && { ownership: { ownerId } },
         roles: ownerId ? {
           [ownerId]: Role.OWNER
@@ -1309,27 +2804,35 @@ var TelegramService = class _TelegramService extends Service {
     };
     await this.runtime.ensureWorldExists(world);
     const generalRoom = {
-      id: createUniqueUuid2(this.runtime, chatId),
+      id: createUniqueUuid2(
+        this.runtime,
+        this.scopedTelegramKey(chatId, accountId)
+      ),
       name: chatTitle,
       source: "telegram",
       type: channelType,
       channelId: chatId,
       serverId: chatId,
-      worldId
+      worldId,
+      metadata: {
+        source: "telegram",
+        accountId,
+        telegram: { accountId, chatId }
+      }
     };
     await this.runtime.ensureRoomExists(generalRoom);
     const rooms = [generalRoom];
     if (chat.type === "supergroup" && chat.is_forum && ctx.message?.message_thread_id) {
-      const topicRoom = await this.buildForumTopicRoom(ctx, worldId);
+      const topicRoom = await this.buildForumTopicRoom(ctx, worldId, accountId);
       if (topicRoom) {
         rooms.push(topicRoom);
         await this.runtime.ensureRoomExists(topicRoom);
       }
     }
-    const entities = await this.buildStandardizedEntities(chat);
+    const entities = await this.buildStandardizedEntities(chat, accountId);
     if (ctx.from) {
-      const senderEntity = this.buildMsgSenderEntity(ctx.from);
-      if (senderEntity && senderEntity.id && !entities.some((e) => e.id === senderEntity.id)) {
+      const senderEntity = this.buildMsgSenderEntity(ctx.from, accountId);
+      if (senderEntity?.id && !entities.some((e) => e.id === senderEntity.id)) {
         entities.push(senderEntity);
         this.syncedEntityIds.add(senderEntity.id);
       }
@@ -1337,9 +2840,11 @@ var TelegramService = class _TelegramService extends Service {
     await this.batchProcessEntities(
       entities,
       generalRoom.id,
-      generalRoom.channelId,
+      generalRoom.name || generalRoom.channelId || chatId,
+      generalRoom.channelId || chatId,
       generalRoom.type,
-      worldId
+      worldId,
+      accountId
     );
     const telegramWorldPayload = {
       runtime: this.runtime,
@@ -1347,18 +2852,25 @@ var TelegramService = class _TelegramService extends Service {
       rooms,
       entities,
       source: "telegram",
+      accountId,
+      metadata: { accountId },
       chat,
-      botUsername: this.bot?.botInfo?.username
+      botUsername: this.getAccountState(accountId)?.bot.botInfo?.username
     };
     if (chat.type !== "private") {
-      await this.runtime.emitEvent("TELEGRAM_WORLD_JOINED" /* WORLD_JOINED */, telegramWorldPayload);
+      await this.runtime.emitEvent(
+        "TELEGRAM_WORLD_JOINED" /* WORLD_JOINED */,
+        telegramWorldPayload
+      );
     }
     await this.runtime.emitEvent(EventType2.WORLD_JOINED, {
       runtime: this.runtime,
       world,
       rooms,
       entities,
-      source: "telegram"
+      source: "telegram",
+      accountId,
+      metadata: { accountId }
     });
   }
   /**
@@ -1372,7 +2884,7 @@ var TelegramService = class _TelegramService extends Service {
    * @returns {Promise<void>}
    * @private
    */
-  async batchProcessEntities(entities, roomId, channelId, roomType, worldId) {
+  async batchProcessEntities(entities, roomId, roomName, channelId, roomType, worldId, accountId = this.defaultAccountId) {
     const batchSize = 50;
     for (let i = 0; i < entities.length; i += batchSize) {
       const entityBatch = entities.slice(i, i + batchSize);
@@ -1384,6 +2896,7 @@ var TelegramService = class _TelegramService extends Service {
               await this.runtime.ensureConnection({
                 entityId: entity.id,
                 roomId,
+                roomName,
                 userName: telegramMetadata?.username,
                 name: telegramMetadata?.name,
                 userId: telegramMetadata?.id,
@@ -1393,11 +2906,28 @@ var TelegramService = class _TelegramService extends Service {
                 worldId
               });
             } else {
-              logger3.warn({ src: "plugin:telegram", agentId: this.runtime.agentId, entityNames: entity.names }, "Skipping entity sync due to missing ID");
+              logger4.warn(
+                {
+                  src: "plugin:telegram",
+                  agentId: this.runtime.agentId,
+                  accountId,
+                  entityNames: entity.names
+                },
+                "Skipping entity sync due to missing ID"
+              );
             }
           } catch (err) {
             const telegramMetadata = entity.metadata?.telegram;
-            logger3.warn({ src: "plugin:telegram", agentId: this.runtime.agentId, username: telegramMetadata?.username, error: err instanceof Error ? err.message : String(err) }, "Failed to sync user");
+            logger4.warn(
+              {
+                src: "plugin:telegram",
+                agentId: this.runtime.agentId,
+                accountId,
+                username: telegramMetadata?.username,
+                error: err instanceof Error ? err.message : String(err)
+              },
+              "Failed to sync user"
+            );
           }
         })
       );
@@ -1415,9 +2945,10 @@ var TelegramService = class _TelegramService extends Service {
    * @private
    */
   getChatTypeInfo(chat) {
+    const chatType = chat.type;
     let chatTitle;
     let channelType;
-    switch (chat.type) {
+    switch (chatType) {
       case "private":
         chatTitle = `Chat with ${chat.first_name || "Unknown User"}`;
         channelType = ChannelType2.DM;
@@ -1435,8 +2966,7 @@ var TelegramService = class _TelegramService extends Service {
         channelType = ChannelType2.FEED;
         break;
       default:
-        chatTitle = "Unknown Chat";
-        channelType = ChannelType2.GROUP;
+        throw new Error(`Unrecognized Telegram chat type: ${String(chatType)}`);
     }
     return { chatTitle, channelType };
   }
@@ -1448,37 +2978,50 @@ var TelegramService = class _TelegramService extends Service {
    * @returns {Promise<Entity[]>} Array of standardized Entity objects
    * @private
    */
-  async buildStandardizedEntities(chat) {
+  async buildStandardizedEntities(chat, accountId = this.defaultAccountId) {
     const entities = [];
     try {
       if (chat.type === "private" && chat.id) {
-        const userId = createUniqueUuid2(this.runtime, chat.id.toString());
+        const userId = createUniqueUuid2(
+          this.runtime,
+          this.scopedTelegramKey(chat.id.toString(), accountId)
+        );
         entities.push({
           id: userId,
           names: [chat.first_name || "Unknown User"],
           agentId: this.runtime.agentId,
           metadata: {
             telegram: {
+              accountId,
               id: chat.id.toString(),
               username: chat.username || "unknown",
               name: chat.first_name || "Unknown User"
             },
-            source: "telegram"
+            source: "telegram",
+            accountId
           }
         });
         this.syncedEntityIds.add(userId);
       } else if (chat.type === "group" || chat.type === "supergroup") {
         try {
-          const admins = await this.bot?.telegram.getChatAdministrators(chat.id);
+          const admins = await this.getAccountState(
+            accountId
+          )?.bot.telegram.getChatAdministrators(chat.id);
           if (admins && admins.length > 0) {
             for (const admin of admins) {
-              const userId = createUniqueUuid2(this.runtime, admin.user.id.toString());
+              const userId = createUniqueUuid2(
+                this.runtime,
+                this.scopedTelegramKey(admin.user.id.toString(), accountId)
+              );
               entities.push({
                 id: userId,
-                names: [admin.user.first_name || admin.user.username || "Unknown Admin"],
+                names: [
+                  admin.user.first_name || admin.user.username || "Unknown Admin"
+                ],
                 agentId: this.runtime.agentId,
                 metadata: {
                   telegram: {
+                    accountId,
                     id: admin.user.id.toString(),
                     username: admin.user.username || "unknown",
                     name: admin.user.first_name || "Unknown Admin",
@@ -1486,6 +3029,7 @@ var TelegramService = class _TelegramService extends Service {
                     adminTitle: admin.custom_title || (admin.status === "creator" ? "Owner" : "Admin")
                   },
                   source: "telegram",
+                  accountId,
                   roles: [admin.status === "creator" ? Role.OWNER : Role.ADMIN]
                 }
               });
@@ -1493,11 +3037,26 @@ var TelegramService = class _TelegramService extends Service {
             }
           }
         } catch (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");
+          logger4.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({ src: "plugin:telegram", agentId: this.runtime.agentId, error: error instanceof Error ? error.message : String(error) }, "Error building standardized entities");
+      logger4.error(
+        {
+          src: "plugin:telegram",
+          agentId: this.runtime.agentId,
+          error: error instanceof Error ? error.message : String(error)
+        },
+        "Error building standardized entities"
+      );
     }
     return entities;
   }
@@ -1510,13 +3069,20 @@ var TelegramService = class _TelegramService extends Service {
    * @returns {Promise<Room | null>} A Promise that resolves with the room or null if not a topic
    * @private
    */
-  async buildForumTopicRoom(ctx, worldId) {
-    if (!ctx.chat || !ctx.message?.message_thread_id) return null;
-    if (ctx.chat.type !== "supergroup" || !ctx.chat.is_forum) return null;
+  async buildForumTopicRoom(ctx, worldId, accountId = this.defaultAccountId) {
+    if (!ctx.chat || !ctx.message?.message_thread_id) {
+      return null;
+    }
+    if (ctx.chat.type !== "supergroup" || !ctx.chat.is_forum) {
+      return null;
+    }
     const chat = ctx.chat;
     const chatId = chat.id.toString();
     const threadId = ctx.message.message_thread_id.toString();
-    const roomId = createUniqueUuid2(this.runtime, `${chatId}-${threadId}`);
+    const roomId = createUniqueUuid2(
+      this.runtime,
+      this.scopedTelegramKey(`${chatId}-${threadId}`, accountId)
+    );
     try {
       const replyMessage = JSON.parse(JSON.stringify(ctx.message));
       let topicName = `Topic #${threadId}`;
@@ -1540,46 +3106,572 @@ var TelegramService = class _TelegramService extends Service {
         serverId: chatId,
         worldId,
         metadata: {
+          source: "telegram",
+          accountId,
           threadId,
           isForumTopic: true,
-          parentChatId: chatId
+          parentChatId: chatId,
+          telegram: {
+            accountId,
+            chatId,
+            threadId
+          }
         }
       };
       return room;
     } catch (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");
+      logger4.error(
+        {
+          src: "plugin:telegram",
+          agentId: this.runtime.agentId,
+          accountId,
+          chatId,
+          threadId,
+          error: error instanceof Error ? error.message : String(error)
+        },
+        "Error building forum topic room"
+      );
+      return null;
+    }
+  }
+  buildConnectorChatTarget(chat, score = 0.5, threadId, accountId = this.defaultAccountId) {
+    const chatId = chat.id.toString();
+    const roomKey = threadId ? `${chatId}-${threadId}` : chatId;
+    const roomId = createUniqueUuid2(
+      this.runtime,
+      this.scopedTelegramKey(roomKey, accountId)
+    );
+    const label = getTelegramChatDisplayName(chat, chatId);
+    return {
+      target: {
+        source: "telegram",
+        accountId,
+        roomId,
+        channelId: roomKey,
+        threadId: threadId?.toString()
+      },
+      label,
+      kind: threadId ? "thread" : telegramChatKind(chat),
+      description: threadId && "title" in chat ? `Telegram topic ${threadId} in ${chat.title}` : `Telegram ${chat.type}`,
+      score,
+      contexts: ["social", "connectors"],
+      metadata: {
+        accountId,
+        telegramChatId: chatId,
+        telegramThreadId: threadId,
+        telegramChatType: chat.type,
+        username: "username" in chat ? chat.username : void 0,
+        title: "title" in chat ? chat.title : void 0
+      }
+    };
+  }
+  buildConnectorRoomTarget(room, score = 0.5) {
+    if (room.source !== "telegram" || !room.channelId) {
+      return null;
+    }
+    const metadata = room.metadata;
+    const accountId = typeof metadata?.accountId === "string" && metadata.accountId.trim() ? normalizeTelegramAccountId(metadata.accountId) : normalizeTelegramAccountId(this.defaultAccountId);
+    const threadId = typeof metadata?.threadId === "string" ? metadata.threadId : typeof room.channelId === "string" ? parseTelegramTargetParts(room.channelId).threadId?.toString() : void 0;
+    return {
+      target: {
+        source: "telegram",
+        accountId,
+        roomId: room.id,
+        channelId: room.channelId,
+        threadId
+      },
+      label: room.name || room.channelId,
+      kind: threadId ? "thread" : "group",
+      description: threadId ? `Telegram topic ${threadId}` : "Telegram chat room",
+      score,
+      contexts: ["social", "connectors"],
+      metadata: {
+        accountId,
+        telegramChatId: room.channelId,
+        telegramThreadId: threadId,
+        roomName: room.name
+      }
+    };
+  }
+  dedupeConnectorTargets(targets) {
+    const byKey = /* @__PURE__ */ new Map();
+    for (const target of targets) {
+      const key = [
+        target.target.accountId ?? "",
+        target.kind ?? "target",
+        target.target.channelId ?? "",
+        target.target.entityId ?? "",
+        target.target.threadId ?? ""
+      ].join(":");
+      const existing = byKey.get(key);
+      if (!existing || (target.score ?? 0) > (existing.score ?? 0)) {
+        byKey.set(key, target);
+      }
+    }
+    return Array.from(byKey.values()).sort(
+      (a, b) => (b.score ?? 0) - (a.score ?? 0)
+    );
+  }
+  async getTelegramChatForTarget(chatId, accountId = this.defaultAccountId) {
+    const known = this.knownChats.get(this.scopedTelegramKey(String(chatId), accountId)) ?? (normalizeTelegramAccountId(accountId) === DEFAULT_ACCOUNT_ID ? this.knownChats.get(String(chatId)) : void 0);
+    if (known) {
+      return known;
+    }
+    const bot = this.getAccountState(accountId)?.bot ?? this.bot;
+    if (!bot) {
+      return null;
+    }
+    try {
+      const chat = await bot.telegram.getChat(chatId);
+      this.knownChats.set(
+        this.scopedTelegramKey(String(chat.id), accountId),
+        chat
+      );
+      return chat;
+    } catch {
+      return null;
+    }
+  }
+  async resolveConnectorTargets(query, context) {
+    const normalizedQuery = normalizeTelegramConnectorQuery(query);
+    const targets = [];
+    const explicitAccountId = this.resolveAccountIdFromContext(
+      context,
+      context.target
+    );
+    const accountIds = explicitAccountId ? [normalizeTelegramAccountId(explicitAccountId)] : this.getAccountIds();
+    for (const accountId of accountIds) {
+      for (const [key, chat] of this.knownChats.entries()) {
+        if (!this.knownChatKeyMatchesAccount(key, chat, accountId)) {
+          continue;
+        }
+        const score = scoreTelegramConnectorMatch(
+          normalizedQuery,
+          chat.id.toString(),
+          [
+            "title" in chat ? chat.title : void 0,
+            "username" in chat ? chat.username : void 0,
+            "first_name" in chat ? chat.first_name : void 0,
+            "last_name" in chat ? chat.last_name : void 0
+          ]
+        );
+        if (score <= 0) {
+          continue;
+        }
+        targets.push(
+          this.buildConnectorChatTarget(chat, score, void 0, accountId)
+        );
+      }
+    }
+    if (normalizedQuery && (TELEGRAM_CHAT_ID_PATTERN.test(normalizedQuery) || query.trim().startsWith("@"))) {
+      const lookup = TELEGRAM_CHAT_ID_PATTERN.test(normalizedQuery) ? normalizedQuery : query.trim();
+      const accountId = accountIds[0] ?? this.defaultAccountId;
+      const chat = await this.getTelegramChatForTarget(lookup, accountId);
+      if (chat) {
+        targets.push(
+          this.buildConnectorChatTarget(chat, 1, void 0, accountId)
+        );
+      }
+    }
+    const room = context.roomId && typeof context.runtime.getRoom === "function" ? await context.runtime.getRoom(context.roomId) : null;
+    if (room) {
+      const roomTarget = this.buildConnectorRoomTarget(room, 0.6);
+      if (roomTarget) {
+        targets.push(roomTarget);
+      }
+    }
+    return this.dedupeConnectorTargets(targets).slice(0, 25);
+  }
+  async listConnectorRooms(context) {
+    const explicitAccountId = this.resolveAccountIdFromContext(
+      context,
+      context.target
+    );
+    const accountIds = explicitAccountId ? [normalizeTelegramAccountId(explicitAccountId)] : this.getAccountIds();
+    const targets = [];
+    for (const accountId of accountIds) {
+      for (const [key, chat] of this.knownChats.entries()) {
+        if (!this.knownChatKeyMatchesAccount(key, chat, accountId)) {
+          continue;
+        }
+        targets.push(
+          this.buildConnectorChatTarget(chat, 0.5, void 0, accountId)
+        );
+      }
+    }
+    const room = context.roomId && typeof context.runtime.getRoom === "function" ? await context.runtime.getRoom(context.roomId) : null;
+    if (room) {
+      const roomTarget = this.buildConnectorRoomTarget(room, 0.7);
+      if (roomTarget) {
+        targets.push(roomTarget);
+      }
+    }
+    return this.dedupeConnectorTargets(targets).slice(0, 50);
+  }
+  async listRecentConnectorTargets(context) {
+    return this.listConnectorRooms(context);
+  }
+  async fetchConnectorMessages(context, params = {}) {
+    const limit = normalizeConnectorLimit(params.limit);
+    const target = params.target ?? context.target;
+    const accountId = await this.resolveAccountIdForTarget(
+      context.runtime,
+      target,
+      { accountId: context.accountId }
+    );
+    if (target?.roomId) {
+      const memories = await context.runtime.getMemories({
+        tableName: "messages",
+        roomId: target.roomId,
+        limit,
+        orderBy: "createdAt",
+        orderDirection: "desc"
+      });
+      return memories.filter((memory) => {
+        const metadata = memory.metadata;
+        return !metadata?.accountId || metadata.accountId === accountId;
+      });
+    }
+    const targets = (await this.listRecentConnectorTargets(context)).slice(
+      0,
+      10
+    );
+    const roomIds = Array.from(
+      new Set(
+        targets.map((candidate) => candidate.target.roomId).filter((roomId) => Boolean(roomId))
+      )
+    );
+    const chunks = await Promise.all(
+      roomIds.map(
+        (roomId) => context.runtime.getMemories({
+          tableName: "messages",
+          roomId,
+          limit,
+          orderBy: "createdAt",
+          orderDirection: "desc"
+        })
+      )
+    );
+    return chunks.flat().filter((memory) => {
+      const metadata = memory.metadata;
+      return !metadata?.accountId || metadata.accountId === accountId;
+    }).sort((left, right) => (right.createdAt ?? 0) - (left.createdAt ?? 0)).slice(0, limit);
+  }
+  async searchConnectorMessages(context, params) {
+    const limit = normalizeConnectorLimit(params.limit);
+    const messages = await this.fetchConnectorMessages(context, {
+      target: params.target ?? context.target,
+      limit: Math.max(limit, 100)
+    });
+    return filterMemoriesByQuery(messages, params.query, limit);
+  }
+  async getConnectorChatContext(target, context) {
+    const room = target.roomId && typeof context.runtime.getRoom === "function" ? await context.runtime.getRoom(target.roomId) : null;
+    const accountId = await this.resolveAccountIdForTarget(
+      context.runtime,
+      target,
+      {
+        accountId: context.accountId,
+        roomId: target.roomId ?? context.roomId
+      }
+    );
+    const channelId = target.channelId ?? room?.channelId;
+    if (!channelId) {
+      return null;
+    }
+    const parts = parseTelegramTargetParts(channelId, target.threadId);
+    const chat = await this.getTelegramChatForTarget(parts.chatId, accountId);
+    const roomId = target.roomId ?? room?.id ?? createUniqueUuid2(
+      this.runtime,
+      this.scopedTelegramKey(
+        parts.threadId ? `${parts.chatId}-${parts.threadId}` : String(parts.chatId),
+        accountId
+      )
+    );
+    const memories = await context.runtime.getMemories({
+      tableName: "messages",
+      roomId,
+      count: 10,
+      orderBy: "createdAt",
+      orderDirection: "desc"
+    });
+    const recentMessages = memories.slice().reverse().map((memory) => ({
+      entityId: memory.entityId,
+      name: typeof memory.content?.name === "string" ? memory.content.name : void 0,
+      text: memory.content?.text ?? "",
+      timestamp: memory.createdAt,
+      metadata: {
+        memoryId: memory.id,
+        accountId,
+        source: memory.content?.source
+      }
+    })).filter((message) => message.text.trim().length > 0);
+    return {
+      target: {
+        source: "telegram",
+        accountId,
+        roomId,
+        channelId,
+        threadId: parts.threadId?.toString()
+      },
+      label: room?.name || (chat ? getTelegramChatDisplayName(chat, String(parts.chatId)) : channelId),
+      summary: chat ? `Telegram ${chat.type}` : void 0,
+      recentMessages,
+      metadata: {
+        accountId,
+        telegramChatId: String(parts.chatId),
+        telegramThreadId: parts.threadId,
+        telegramChatType: chat?.type
+      }
+    };
+  }
+  async getConnectorUserContext(entityId, context) {
+    const accountId = normalizeTelegramAccountId(
+      context.target?.accountId ?? context.accountId ?? context.account?.accountId ?? this.defaultAccountId
+    );
+    const entity = typeof context.runtime.getEntityById === "function" ? await context.runtime.getEntityById(String(entityId)) : null;
+    const telegramMetadata = entity?.metadata?.telegram && typeof entity.metadata.telegram === "object" ? entity.metadata.telegram : null;
+    const telegramId = typeof telegramMetadata?.id === "number" || typeof telegramMetadata?.id === "string" ? telegramMetadata.id : TELEGRAM_CHAT_ID_PATTERN.test(String(entityId)) ? entityId : null;
+    if (!telegramId) {
       return null;
     }
+    const chat = await this.getTelegramChatForTarget(telegramId, accountId);
+    const aliases = [
+      entity?.names?.[0],
+      chat && "username" in chat ? chat.username : void 0,
+      chat && "first_name" in chat ? chat.first_name : void 0,
+      chat && "last_name" in chat ? chat.last_name : void 0
+    ].filter((value) => Boolean(value));
+    return {
+      entityId,
+      label: aliases[0] ?? String(telegramId),
+      aliases,
+      handles: { telegram: String(telegramId) },
+      metadata: {
+        accountId,
+        telegramId: String(telegramId),
+        telegramChatType: chat?.type,
+        username: chat && "username" in chat ? chat.username : void 0
+      }
+    };
   }
   static registerSendHandlers(runtime, serviceInstance) {
-    if (serviceInstance && serviceInstance.bot) {
-      runtime.registerSendHandler(
-        "telegram",
-        serviceInstance.handleSendMessage.bind(serviceInstance)
+    if (serviceInstance?.bot) {
+      const registerConnector = (accountId) => {
+        const normalizedAccountId = accountId ? normalizeTelegramAccountId(accountId) : void 0;
+        const state = normalizedAccountId ? serviceInstance.getAccountState(normalizedAccountId) : serviceInstance.getDefaultAccountState();
+        const sendHandler = async (handlerRuntime, target, content) => {
+          await serviceInstance.handleSendMessage(
+            handlerRuntime,
+            normalizedAccountId && !target.accountId ? { ...target, accountId: normalizedAccountId } : target,
+            content
+          );
+          return void 0;
+        };
+        const withContextAccount = (context) => normalizedAccountId && !context.accountId ? {
+          ...context,
+          accountId: normalizedAccountId,
+          account: context.account ?? {
+            source: "telegram",
+            accountId: normalizedAccountId,
+            label: state?.account.name ?? normalizedAccountId
+          }
+        } : context;
+        const registration = {
+          source: "telegram",
+          ...normalizedAccountId ? { accountId: normalizedAccountId } : {},
+          ...normalizedAccountId ? {
+            account: {
+              source: "telegram",
+              accountId: normalizedAccountId,
+              label: state?.account.name ?? normalizedAccountId,
+              authMethod: "BOT_TOKEN"
+            }
+          } : {},
+          label: state?.account.name ? `Telegram (${state.account.name})` : "Telegram",
+          description: "Telegram connector for sending messages to chats, topics, and users.",
+          capabilities: [...TELEGRAM_CONNECTOR_CAPABILITIES],
+          supportedTargetKinds: ["channel", "group", "thread", "user"],
+          contexts: [...TELEGRAM_CONNECTOR_CONTEXTS],
+          metadata: {
+            service: TELEGRAM_SERVICE_NAME,
+            ...normalizedAccountId ? { accountId: normalizedAccountId } : {}
+          },
+          resolveTargets: (query, context) => serviceInstance.resolveConnectorTargets(
+            query,
+            withContextAccount(context)
+          ),
+          listRecentTargets: (context) => serviceInstance.listRecentConnectorTargets(
+            withContextAccount(context)
+          ),
+          listRooms: (context) => serviceInstance.listConnectorRooms(withContextAccount(context)),
+          fetchMessages: (context, params) => {
+            const readParams = params ?? {};
+            return serviceInstance.fetchConnectorMessages(
+              withContextAccount(context),
+              {
+                ...readParams,
+                target: normalizedAccountId && readParams.target && !readParams.target.accountId ? {
+                  ...readParams.target,
+                  accountId: normalizedAccountId
+                } : readParams.target
+              }
+            );
+          },
+          searchMessages: (context, params) => serviceInstance.searchConnectorMessages(
+            withContextAccount(context),
+            {
+              ...params,
+              target: normalizedAccountId && params.target && !params.target.accountId ? {
+                ...params.target,
+                accountId: normalizedAccountId
+              } : params.target
+            }
+          ),
+          getChatContext: (target, context) => serviceInstance.getConnectorChatContext(
+            normalizedAccountId && !target.accountId ? { ...target, accountId: normalizedAccountId } : target,
+            withContextAccount(context)
+          ),
+          getUserContext: (entityId, context) => serviceInstance.getConnectorUserContext(
+            entityId,
+            withContextAccount(context)
+          ),
+          getUser: async (handlerRuntime, params) => {
+            const userParams = params;
+            const entityId = String(
+              userParams.entityId ?? userParams.userId ?? userParams.username ?? userParams.handle ?? ""
+            ).trim();
+            if (!entityId) {
+              return null;
+            }
+            const entity = typeof handlerRuntime.getEntityById === "function" ? await handlerRuntime.getEntityById(entityId).catch(() => null) : null;
+            if (entity) {
+              return entity;
+            }
+            const context = await serviceInstance.getConnectorUserContext(
+              entityId,
+              {
+                runtime: handlerRuntime,
+                accountId: normalizedAccountId
+              }
+            );
+            if (!context) {
+              return null;
+            }
+            return {
+              id: createUniqueUuid2(
+                handlerRuntime,
+                serviceInstance.scopedTelegramKey(
+                  `telegram:${context.handles?.telegram ?? entityId}`,
+                  normalizedAccountId
+                )
+              ),
+              names: context.aliases?.length ? context.aliases : [context.label ?? entityId],
+              agentId: handlerRuntime.agentId,
+              metadata: {
+                ...context.metadata,
+                ...normalizedAccountId ? { accountId: normalizedAccountId } : {}
+              }
+            };
+          },
+          sendHandler
+        };
+        runtime.registerMessageConnector(registration);
+      };
+      if (typeof runtime.registerMessageConnector === "function") {
+        registerConnector();
+        for (const accountId of serviceInstance.getAccountIds()) {
+          registerConnector(accountId);
+        }
+      } else {
+        runtime.registerSendHandler(
+          "telegram",
+          serviceInstance.handleSendMessage.bind(serviceInstance)
+        );
+      }
+      logger4.info(
+        { src: "plugin:telegram", agentId: runtime.agentId },
+        "Registered Telegram message connector"
       );
-      logger3.info({ src: "plugin:telegram", agentId: runtime.agentId }, "Registered send handler");
     } else {
-      logger3.warn({ src: "plugin:telegram", agentId: runtime.agentId }, "Cannot register send handler, bot not initialized");
+      logger4.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({ 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.");
+    const accountId = await this.resolveAccountIdForTarget(runtime, target);
+    const accountState = this.getAccountState(accountId);
+    const messageManager = accountState?.messageManager ?? this.messageManager;
+    const bot = accountState?.bot ?? this.bot;
+    if (!bot || !messageManager) {
+      logger4.error(
+        { src: "plugin:telegram", agentId: runtime.agentId, accountId },
+        "Bot not initialized, cannot send messages"
+      );
+      throw new Error(
+        "Telegram bot is not initialized. Please provide TELEGRAM_BOT_TOKEN."
+      );
     }
     let chatId;
+    let threadId;
     if (target.channelId) {
-      chatId = target.channelId;
+      const parts = parseTelegramTargetParts(target.channelId, target.threadId);
+      chatId = parts.chatId;
+      threadId = parts.threadId;
     } else if (target.roomId) {
       const room = await runtime.getRoom(target.roomId);
-      chatId = room?.channelId;
-      if (!chatId)
-        throw new Error(`Could not resolve Telegram chat ID from roomId ${target.roomId}`);
+      const metadata = room?.metadata;
+      const metadataThreadId = typeof metadata?.threadId === "string" ? metadata.threadId : void 0;
+      if (room?.channelId) {
+        const parts = parseTelegramTargetParts(
+          room.channelId,
+          metadataThreadId
+        );
+        chatId = parts.chatId;
+        threadId = parts.threadId;
+      }
+      if (!chatId) {
+        throw new Error(
+          `Could not resolve Telegram chat ID from roomId ${target.roomId}`
+        );
+      }
     } else if (target.entityId) {
-      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.");
+      const entity = await runtime.getEntityById(target.entityId);
+      if (!entity) {
+        throw new Error(`Entity ${target.entityId} not found`);
+      }
+      const telegramMeta = entity.metadata?.telegram;
+      const entityAccountId = typeof entity.metadata?.accountId === "string" ? entity.metadata.accountId : typeof telegramMeta?.accountId === "string" ? telegramMeta.accountId : void 0;
+      if (entityAccountId && normalizeTelegramAccountId(entityAccountId) !== accountId) {
+        throw new Error(
+          `Entity ${target.entityId} is linked to Telegram account ${entityAccountId}, not ${accountId}`
+        );
+      }
+      const telegramId = telegramMeta?.id;
+      if (!telegramId) {
+        logger4.error(
+          {
+            src: "plugin:telegram",
+            agentId: runtime.agentId,
+            accountId,
+            entityId: target.entityId
+          },
+          "Entity has no telegram.id in metadata \u2014 cannot send DM without Telegram user ID"
+        );
+        throw new Error(
+          `Entity ${target.entityId} has no telegram.id in metadata \u2014 cannot send DM without Telegram user ID`
+        );
+      }
+      chatId = telegramId;
+      if (target.threadId && /^\d+$/.test(target.threadId)) {
+        threadId = Number.parseInt(target.threadId, 10);
+      }
     } else {
-      throw new Error("Telegram SendHandler requires channelId, roomId, or entityId.");
+      throw new Error(
+        "Telegram SendHandler requires channelId, roomId, or entityId."
+      );
     }
     if (!chatId) {
       throw new Error(
@@ -1587,17 +3679,189 @@ var TelegramService = class _TelegramService extends Service {
       );
     }
     try {
-      await this.messageManager.sendMessage(chatId, content);
-      logger3.info({ src: "plugin:telegram", agentId: runtime.agentId, chatId }, "Message sent");
+      await messageManager.sendMessage(
+        chatId,
+        {
+          ...content,
+          metadata: {
+            ...content.metadata && typeof content.metadata === "object" ? content.metadata : {},
+            accountId
+          }
+        },
+        void 0,
+        threadId
+      );
+      logger4.info(
+        {
+          src: "plugin:telegram",
+          agentId: runtime.agentId,
+          accountId,
+          chatId,
+          threadId
+        },
+        "Message sent"
+      );
     } catch (error) {
-      logger3.error({ src: "plugin:telegram", agentId: runtime.agentId, chatId, error: error instanceof Error ? error.message : String(error) }, "Error sending message");
+      logger4.error(
+        {
+          src: "plugin:telegram",
+          agentId: runtime.agentId,
+          accountId,
+          chatId,
+          error: error instanceof Error ? error.message : String(error)
+        },
+        "Error sending message"
+      );
       throw error;
     }
   }
 };
 
+// src/setup-routes.ts
+import { logger as logger5 } from "@elizaos/core";
+var TELEGRAM_API_BASE = "https://api.telegram.org";
+function isConnectorSetupService2(service) {
+  if (!service || typeof service !== "object") {
+    return false;
+  }
+  const candidate = service;
+  return typeof candidate.getConfig === "function" && typeof candidate.updateConfig === "function" && typeof candidate.persistConfig === "function" && typeof candidate.registerEscalationChannel === "function" && typeof candidate.setOwnerContact === "function";
+}
+function getSetupService2(runtime) {
+  const service = runtime.getService("connector-setup");
+  return isConnectorSetupService2(service) ? service : null;
+}
+async function readJsonBody(req) {
+  return req.body ?? null;
+}
+async function handleValidateToken(req, res, runtime) {
+  const body = await readJsonBody(req);
+  const token = typeof body?.token === "string" ? body.token.trim() : "";
+  if (!token) {
+    res.status(200).json({ ok: false, error: "token is required" });
+    return;
+  }
+  if (!/^\d+:[A-Za-z0-9_-]{30,}$/.test(token)) {
+    res.status(200).json({
+      ok: false,
+      error: "Token format invalid. Expected format: 123456:ABC-DEF..."
+    });
+    return;
+  }
+  try {
+    const apiRes = await fetch(`${TELEGRAM_API_BASE}/bot${token}/getMe`, {
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!apiRes.ok) {
+      res.status(200).json({
+        ok: false,
+        error: `Telegram API returned ${apiRes.status}. Check that the token is correct.`
+      });
+      return;
+    }
+    const data = await apiRes.json();
+    if (!data.ok || !data.result) {
+      res.status(200).json({
+        ok: false,
+        error: "Telegram API returned unexpected response"
+      });
+      return;
+    }
+    const bot = data.result;
+    const setupService = getSetupService2(runtime);
+    if (setupService) {
+      setupService.updateConfig((config) => {
+        if (!config.connectors) {
+          config.connectors = {};
+        }
+        const connectors = config.connectors;
+        if (!connectors.telegram || typeof connectors.telegram !== "object") {
+          connectors.telegram = {};
+        }
+        connectors.telegram.botToken = token;
+      });
+      setupService.setOwnerContact({
+        source: "telegram",
+        channelId: String(bot.id)
+      });
+      setupService.registerEscalationChannel("telegram");
+    } else {
+      logger5.warn(
+        "[telegram-setup] connector-setup service not available \u2014 token saved to runtime only"
+      );
+    }
+    res.status(200).json({
+      ok: true,
+      bot: {
+        id: bot.id,
+        username: bot.username,
+        firstName: bot.first_name
+      }
+    });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    res.status(200).json({
+      ok: false,
+      error: `Failed to reach Telegram API: ${message}`
+    });
+  }
+}
+async function handleStatus2(_req, res, runtime) {
+  const setupService = getSetupService2(runtime);
+  let hasToken = false;
+  if (setupService) {
+    const config = setupService.getConfig();
+    const connectors = config.connectors ?? {};
+    const tgConfig = connectors.telegram;
+    hasToken = Boolean(tgConfig?.botToken);
+  }
+  if (!hasToken) {
+    hasToken = Boolean(runtime.getSetting("TELEGRAM_BOT_TOKEN"));
+  }
+  const service = runtime.getService("telegram");
+  const connected = Boolean(service);
+  res.status(200).json({
+    available: true,
+    hasToken,
+    connected
+  });
+}
+async function handleDisconnect2(_req, res, runtime) {
+  const setupService = getSetupService2(runtime);
+  if (setupService) {
+    setupService.updateConfig((config) => {
+      const connectors = config.connectors ?? {};
+      const tgConfig = connectors.telegram;
+      if (tgConfig) {
+        delete tgConfig.botToken;
+      }
+    });
+  }
+  res.status(200).json({ ok: true });
+}
+var telegramSetupRoutes = [
+  {
+    type: "POST",
+    path: "/api/telegram-setup/validate-token",
+    handler: handleValidateToken,
+    rawPath: true
+  },
+  {
+    type: "GET",
+    path: "/api/telegram-setup/status",
+    handler: handleStatus2,
+    rawPath: true
+  },
+  {
+    type: "POST",
+    path: "/api/telegram-setup/disconnect",
+    handler: handleDisconnect2,
+    rawPath: true
+  }
+];
+
 // src/tests.ts
-import { logger as logger4 } from "@elizaos/core";
+import { logger as logger6 } 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";
@@ -1666,7 +3930,7 @@ var TelegramTestSuite = class {
         throw new Error("Bot is not initialized.");
       }
       const chat = await this.bot.telegram.getChat(chatId);
-      logger4.debug({ src: "plugin:telegram", chatId }, "Fetched real chat");
+      logger6.debug({ src: "plugin:telegram", chatId }, "Fetched real chat");
       return chat;
     } catch (error) {
       throw new Error(`Error fetching real Telegram chat: ${error}`);
@@ -1674,29 +3938,41 @@ var TelegramTestSuite = class {
   }
   async testCreatingTelegramBot(runtime) {
     this.telegramClient = runtime.getService("telegram");
-    if (!this.telegramClient || !this.telegramClient.messageManager) {
+    if (!this.telegramClient?.messageManager) {
       throw new Error(
         "Telegram service or message manager not initialized - check TELEGRAM_BOT_TOKEN"
       );
     }
     this.bot = this.telegramClient.messageManager.bot;
     this.messageManager = this.telegramClient.messageManager;
-    logger4.debug({ src: "plugin:telegram" }, "Telegram bot initialized successfully");
+    logger6.debug(
+      { src: "plugin:telegram" },
+      "Telegram bot initialized successfully"
+    );
   }
   async testSendingTextMessage(runtime) {
     try {
-      if (!this.bot) throw new Error("Bot not initialized.");
+      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({ src: "plugin:telegram", chatId }, "Message sent successfully");
+      logger6.debug(
+        { src: "plugin:telegram", chatId },
+        "Message sent successfully"
+      );
     } catch (error) {
       throw new Error(`Error sending Telegram message: ${error}`);
     }
   }
   async testSendingMessageWithAttachment(runtime) {
     try {
-      if (!this.messageManager) throw new Error("MessageManager not initialized.");
-      if (!this.bot) throw new Error("Bot not initialized.");
+      if (!this.messageManager) {
+        throw new Error("MessageManager not initialized.");
+      }
+      if (!this.bot) {
+        throw new Error("Bot not initialized.");
+      }
       const chat = await this.getChatInfo(runtime);
       const mockContext = {
         chat,
@@ -1721,15 +3997,24 @@ var TelegramTestSuite = class {
         mockContext,
         messageContent
       );
-      logger4.success({ src: "plugin:telegram" }, "Message with image attachment sent successfully");
+      logger6.success(
+        { src: "plugin:telegram" },
+        "Message with image attachment sent successfully"
+      );
     } catch (error) {
-      throw new Error(`Error sending Telegram message with attachment: ${error}`);
+      throw new Error(
+        `Error sending Telegram message with attachment: ${error}`
+      );
     }
   }
   async testHandlingMessage(runtime) {
     try {
-      if (!this.bot) throw new Error("Bot not initialized.");
-      if (!this.messageManager) throw new Error("MessageManager not initialized.");
+      if (!this.bot) {
+        throw new Error("Bot not initialized.");
+      }
+      if (!this.messageManager) {
+        throw new Error("MessageManager not initialized.");
+      }
       const chat = await this.getChatInfo(runtime);
       const mockContext = {
         chat,
@@ -1741,7 +4026,7 @@ var TelegramTestSuite = class {
           last_name: "User"
         },
         message: {
-          message_id: void 0,
+          message_id: 12345,
           text: `@${this.bot.botInfo?.username}! Hello!`,
           date: Math.floor(Date.now() / 1e3),
           chat
@@ -1759,8 +4044,12 @@ var TelegramTestSuite = class {
   }
   async testProcessingImages(runtime) {
     try {
-      if (!this.bot) throw new Error("Bot not initialized.");
-      if (!this.messageManager) throw new Error("MessageManager not initialized.");
+      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(String(chatId), TEST_IMAGE_URL);
       const mockMessage = {
@@ -1777,12 +4066,19 @@ var TelegramTestSuite = class {
         ],
         text: `@${this.bot.botInfo?.username}!`
       };
-      const result = await this.messageManager.processImage(mockMessage);
-      if (!result || !result.description) {
-        throw new Error("Error processing Telegram image or description not found");
+      const result = await this.messageManager.processImage(
+        mockMessage
+      );
+      if (!result?.description) {
+        throw new Error(
+          "Error processing Telegram image or description not found"
+        );
       }
       const { description } = result;
-      logger4.debug({ src: "plugin:telegram", description }, "Processing Telegram image successfully");
+      logger6.debug(
+        { src: "plugin:telegram", description },
+        "Processing Telegram image successfully"
+      );
     } catch (error) {
       throw new Error(`Error processing Telegram image: ${error}`);
     }
@@ -1793,12 +4089,19 @@ var TelegramTestSuite = class {
         throw new Error("Bot is not initialized.");
       }
       const message = await this.bot.telegram.sendPhoto(chatId, imageUrl);
-      if (!message.photo || message.photo.length === 0) {
+      if (message.photo.length === 0) {
         throw new Error("No photo received in the message response.");
       }
       return message.photo[message.photo.length - 1].file_id;
     } catch (error) {
-      logger4.error({ src: "plugin:telegram", chatId, error: error instanceof Error ? error.message : String(error) }, "Error sending image");
+      logger6.error(
+        {
+          src: "plugin:telegram",
+          chatId,
+          error: error instanceof Error ? error.message : String(error)
+        },
+        "Error sending image"
+      );
       throw error;
     }
   }
@@ -1808,13 +4111,57 @@ var TelegramTestSuite = class {
 var telegramPlugin = {
   name: TELEGRAM_SERVICE_NAME,
   description: "Telegram client plugin",
-  services: [TelegramService],
-  tests: [new TelegramTestSuite()]
+  // TelegramService must come before TelegramOwnerPairingServiceImpl so the
+  // bot instance exists when the pairing service registers its command.
+  services: [TelegramService, TelegramOwnerPairingServiceImpl],
+  routes: [...telegramSetupRoutes, ...telegramAccountRoutes],
+  tests: [new TelegramTestSuite()],
+  // Self-declared auto-enable: activate when the "telegram" connector is
+  // configured in eliza.json / eliza.json. The hardcoded CONNECTOR_PLUGINS
+  // map in plugin-auto-enable.ts still serves as a fallback.
+  autoEnable: {
+    connectorKeys: ["telegram"]
+  },
+  init: async (_config, runtime) => {
+    try {
+      const manager = getConnectorAccountManager(runtime);
+      manager.registerProvider(createTelegramConnectorAccountProvider(runtime));
+    } catch (err) {
+      logger7.warn(
+        {
+          src: "plugin:telegram",
+          err: err instanceof Error ? err.message : String(err)
+        },
+        "Failed to register Telegram provider with ConnectorAccountManager"
+      );
+    }
+  }
 };
 var index_default = telegramPlugin;
 export {
+  DEFAULT_ACCOUNT_ID,
   MessageManager,
+  TELEGRAM_OWNER_PAIRING_SERVICE_TYPE,
+  TelegramAccountAuthSession,
+  TelegramOwnerPairingServiceImpl,
   TelegramService,
-  index_default as default
+  clearTelegramAccountAuthState,
+  clearTelegramAccountSession,
+  createTelegramConnectorAccountProvider,
+  index_default as default,
+  defaultTelegramAccountDeviceModel,
+  defaultTelegramAccountSystemVersion,
+  getTelegramMultiAccountConfig,
+  listEnabledTelegramAccounts,
+  listTelegramAccountIds,
+  loadTelegramAccountSessionString,
+  normalizeTelegramAccountId,
+  resolveDefaultTelegramAccountId,
+  resolveTelegramAccount,
+  resolveTelegramAccountSessionFile,
+  saveTelegramAccountSessionString,
+  stopTelegramAccountAuthSession,
+  telegramAccountAuthStateExists,
+  telegramAccountSessionExists
 };
 //# sourceMappingURL=index.js.map