@chrysb/alphaclaw 0.5.6 → 0.5.7-beta.0

package/lib/server/routes/telegram.js

@@ -51,6 +51,78 @@ const buildTelegramGitSyncCommand = (action, target = "") => {
   return `alphaclaw git-sync -m ${quoteShellArg(message, { strategy: "single" })}`;
 };
 
+const { createTelegramApi } = require("../telegram-api");
+
+const kTelegramEnvKeyBase = "TELEGRAM_BOT_TOKEN";
+const normalizeAccountId = (value) => String(value || "").trim() || "default";
+
+const deriveAccountEnvKey = (accountId) => {
+  const normalized = normalizeAccountId(accountId);
+  if (normalized === "default") return kTelegramEnvKeyBase;
+  return `${kTelegramEnvKeyBase}_${normalized.replace(/-/g, "_").toUpperCase()}`;
+};
+
+const resolveAccountTelegramApi = (accountId, defaultApi) => {
+  const normalized = normalizeAccountId(accountId);
+  if (normalized === "default") return defaultApi;
+  const envKey = deriveAccountEnvKey(normalized);
+  const token = process.env[envKey];
+  if (!token) {
+    console.log(
+      `[alphaclaw] Telegram account "${normalized}": env var ${envKey} not found, falling back to default token`,
+    );
+    return defaultApi;
+  }
+  return createTelegramApi(() => process.env[envKey]);
+};
+
+const resolveAccountId = (req) =>
+  normalizeAccountId(req.query?.accountId || req.body?.accountId || "");
+
+const resolveTelegramConfigForAccount = ({ telegramConfig, accountId }) => {
+  const normalizedAccountId = normalizeAccountId(accountId);
+  const accounts =
+    telegramConfig?.accounts && typeof telegramConfig.accounts === "object"
+      ? telegramConfig.accounts
+      : null;
+  const hasAccounts = !!accounts && Object.keys(accounts).length > 0;
+  if (hasAccounts) {
+    const accountConfig =
+      accounts[normalizedAccountId] &&
+      typeof accounts[normalizedAccountId] === "object"
+        ? accounts[normalizedAccountId]
+        : {};
+    return { normalizedAccountId, hasAccounts, accountConfig };
+  }
+  return {
+    normalizedAccountId,
+    hasAccounts: false,
+    accountConfig: telegramConfig || {},
+  };
+};
+
+const hasScopedBindingFields = (match) =>
+  !!match.peer ||
+  !!match.parentPeer ||
+  !!String(match.guildId || "").trim() ||
+  !!String(match.teamId || "").trim() ||
+  (Array.isArray(match.roles) && match.roles.length > 0);
+
+const resolveBoundAgentIdForAccount = ({ cfg, accountId }) => {
+  const bindings = Array.isArray(cfg?.bindings) ? cfg.bindings : [];
+  const normalizedAccountId = normalizeAccountId(accountId);
+  for (const binding of bindings) {
+    const match = binding?.match || {};
+    if (hasScopedBindingFields(match)) continue;
+    if (String(match.channel || "").trim() !== "telegram") continue;
+    const bindingAccountId = normalizeAccountId(match.accountId);
+    if (bindingAccountId !== normalizedAccountId) continue;
+    const boundAgentId = String(binding?.agentId || "").trim();
+    if (boundAgentId) return boundAgentId;
+  }
+  return normalizedAccountId === "default" ? "default" : "";
+};
+
 const registerTelegramRoutes = ({
   app,
   telegramApi,
@@ -59,18 +131,24 @@ const registerTelegramRoutes = ({
 }) => {
   const repairGroupAllowFromIfMissing = async ({
     cfg,
+    accountId = "default",
     groupId,
     requireMention = false,
+    tgApi = telegramApi,
   }) => {
     const telegramConfig = cfg?.channels?.telegram || {};
+    const { accountConfig } = resolveTelegramConfigForAccount({
+      telegramConfig,
+      accountId,
+    });
     if (
-      Array.isArray(telegramConfig.groupAllowFrom) &&
-      telegramConfig.groupAllowFrom.length > 0
+      Array.isArray(accountConfig.groupAllowFrom) &&
+      accountConfig.groupAllowFrom.length > 0
     ) {
       return { repaired: false, resolvedUserId: "", syncWarning: null };
     }
     const resolvedUserId = await resolveAllowUserId({
-      telegramApi,
+      telegramApi: tgApi,
       groupId,
       preferredUserId: "",
     });
@@ -79,6 +157,7 @@ const registerTelegramRoutes = ({
       openclawDir: OPENCLAW_DIR,
       topicRegistry,
       groupId,
+      accountId,
       requireMention,
       resolvedUserId,
     });
@@ -104,8 +183,10 @@ const registerTelegramRoutes = ({
   // Verify bot token
   app.get("/api/telegram/bot", async (req, res) => {
     try {
-      const me = await telegramApi.getMe();
-      res.json({ ok: true, bot: me });
+      const reqAccountId = resolveAccountId(req);
+      const tgApi = resolveAccountTelegramApi(reqAccountId, telegramApi);
+      const me = await tgApi.getMe();
+      res.json({ ok: true, bot: me, accountId: reqAccountId || "default" });
     } catch (e) {
       res.json({ ok: false, error: e.message });
     }
@@ -118,11 +199,15 @@ const registerTelegramRoutes = ({
       return res.status(400).json({ ok: false, error: "groupId is required" });
 
     try {
-      const chat = await telegramApi.getChat(groupId);
-      const me = await telegramApi.getMe();
-      const member = await telegramApi.getChatMember(groupId, me.id);
-      const suggestedUserId = await resolveAllowUserId({
+      const tgApi = resolveAccountTelegramApi(
+        resolveAccountId(req),
         telegramApi,
+      );
+      const chat = await tgApi.getChat(groupId);
+      const me = await tgApi.getMe();
+      const member = await tgApi.getChatMember(groupId, me.id);
+      const suggestedUserId = await resolveAllowUserId({
+        telegramApi: tgApi,
         groupId,
         preferredUserId: "",
       });
@@ -166,6 +251,8 @@ const registerTelegramRoutes = ({
     const systemInstructions = String(
       body.systemInstructions ?? body.systemPrompt ?? "",
     ).trim();
+    const hasAgentId = Object.prototype.hasOwnProperty.call(body, "agentId");
+    const agentId = String(body.agentId ?? "").trim();
     const iconColorValue =
       rawIconColor == null ? null : Number.parseInt(String(rawIconColor), 10);
     const iconColor = Number.isFinite(iconColorValue)
@@ -175,7 +262,11 @@ const registerTelegramRoutes = ({
       return res.status(400).json({ ok: false, error: "name is required" });
 
     try {
-      const result = await telegramApi.createForumTopic(groupId, name, {
+      const tgApi = resolveAccountTelegramApi(
+        resolveAccountId(req),
+        telegramApi,
+      );
+      const result = await tgApi.createForumTopic(groupId, name, {
         iconColor,
       });
       const threadId = result.message_thread_id;
@@ -183,12 +274,14 @@ const registerTelegramRoutes = ({
         name: result.name,
         iconColor: result.icon_color,
         ...(systemInstructions ? { systemInstructions } : {}),
+        ...(hasAgentId ? { agentId: agentId || undefined } : {}),
       });
       syncConfigForTelegram({
         fs,
         openclawDir: OPENCLAW_DIR,
         topicRegistry,
         groupId,
+        accountId: resolveAccountId(req),
         requireMention: false,
         resolvedUserId: "",
       });
@@ -200,6 +293,7 @@ const registerTelegramRoutes = ({
           threadId,
           name: result.name,
           iconColor: result.icon_color,
+          ...(hasAgentId ? { agentId } : {}),
         },
         syncWarning,
       });
@@ -219,6 +313,7 @@ const registerTelegramRoutes = ({
         .json({ ok: false, error: "topics array is required" });
     }
 
+    const tgApi = resolveAccountTelegramApi(resolveAccountId(req), telegramApi);
     const results = [];
     for (const t of topics) {
       if (!t.name) {
@@ -226,17 +321,20 @@ const registerTelegramRoutes = ({
         continue;
       }
       try {
-        const result = await telegramApi.createForumTopic(groupId, t.name, {
+        const result = await tgApi.createForumTopic(groupId, t.name, {
           iconColor: t.iconColor || undefined,
         });
         const threadId = result.message_thread_id;
         const systemInstructions = String(
           t.systemInstructions ?? t.systemPrompt ?? "",
         ).trim();
+        const hasAgentId = Object.prototype.hasOwnProperty.call(t, "agentId");
+        const agentId = String(t.agentId ?? "").trim();
         topicRegistry.addTopic(groupId, threadId, {
           name: result.name,
           iconColor: result.icon_color,
           ...(systemInstructions ? { systemInstructions } : {}),
+          ...(hasAgentId ? { agentId: agentId || undefined } : {}),
         });
         results.push({ name: result.name, threadId, ok: true });
       } catch (e) {
@@ -248,6 +346,7 @@ const registerTelegramRoutes = ({
       openclawDir: OPENCLAW_DIR,
       topicRegistry,
       groupId,
+      accountId: resolveAccountId(req),
       requireMention: false,
       resolvedUserId: "",
     });
@@ -262,13 +361,18 @@ const registerTelegramRoutes = ({
     async (req, res) => {
       const { groupId, topicId } = req.params;
       try {
-        await telegramApi.deleteForumTopic(groupId, parseInt(topicId, 10));
+        const tgApi = resolveAccountTelegramApi(
+          resolveAccountId(req),
+          telegramApi,
+        );
+        await tgApi.deleteForumTopic(groupId, parseInt(topicId, 10));
         topicRegistry.removeTopic(groupId, topicId);
         syncConfigForTelegram({
           fs,
           openclawDir: OPENCLAW_DIR,
           topicRegistry,
           groupId,
+          accountId: resolveAccountId(req),
           requireMention: false,
           resolvedUserId: "",
         });
@@ -285,6 +389,7 @@ const registerTelegramRoutes = ({
           openclawDir: OPENCLAW_DIR,
           topicRegistry,
           groupId,
+          accountId: resolveAccountId(req),
           requireMention: false,
           resolvedUserId: "",
         });
@@ -304,7 +409,7 @@ const registerTelegramRoutes = ({
     },
   );
 
-  // Rename a topic
+  // Update a topic (rename, system instructions, agent routing)
   app.put("/api/telegram/groups/:groupId/topics/:topicId", async (req, res) => {
     const { groupId, topicId } = req.params;
     const body = req.body || {};
@@ -315,6 +420,8 @@ const registerTelegramRoutes = ({
     const systemInstructions = String(
       body.systemInstructions ?? body.systemPrompt ?? "",
     ).trim();
+    const hasAgentId = Object.prototype.hasOwnProperty.call(body, "agentId");
+    const agentId = String(body.agentId ?? "").trim();
     if (!name)
       return res.status(400).json({ ok: false, error: "name is required" });
     try {
@@ -324,13 +431,17 @@ const registerTelegramRoutes = ({
           .status(400)
           .json({ ok: false, error: "topicId must be numeric" });
       }
+      const tgApi = resolveAccountTelegramApi(
+        resolveAccountId(req),
+        telegramApi,
+      );
       const existingTopic =
         topicRegistry.getGroup(groupId)?.topics?.[String(threadId)] || {};
       const existingName = String(existingTopic.name || "").trim();
       const shouldRename = !existingName || existingName !== name;
       if (shouldRename) {
         try {
-          await telegramApi.editForumTopic(groupId, threadId, { name });
+          await tgApi.editForumTopic(groupId, threadId, { name });
         } catch (e) {
           // Telegram returns TOPIC_NOT_MODIFIED when the name is unchanged.
           if (!String(e.message || "").includes("TOPIC_NOT_MODIFIED")) {
@@ -342,23 +453,26 @@ const registerTelegramRoutes = ({
         ...existingTopic,
         name,
         ...(hasSystemInstructions ? { systemInstructions } : {}),
+        ...(hasAgentId ? { agentId: agentId || undefined } : {}),
       });
       syncConfigForTelegram({
         fs,
         openclawDir: OPENCLAW_DIR,
         topicRegistry,
         groupId,
+        accountId: resolveAccountId(req),
         requireMention: false,
         resolvedUserId: "",
       });
       syncPromptFiles();
-      const syncWarning = await runTelegramGitSync("rename-topic", name);
+      const syncWarning = await runTelegramGitSync("update-topic", name);
       return res.json({
         ok: true,
         topic: {
           threadId,
           name,
           ...(hasSystemInstructions ? { systemInstructions } : {}),
+          ...(hasAgentId ? { agentId } : {}),
         },
         syncWarning,
       });
@@ -373,10 +487,15 @@ const registerTelegramRoutes = ({
     const body = req.body || {};
     const userId = body.userId ?? "";
     const groupName = body.groupName ?? "";
+    const accountId = resolveAccountId(req);
     const requireMention = parseBooleanValue(body.requireMention, false);
     try {
-      const resolvedUserId = await resolveAllowUserId({
+      const tgApi = resolveAccountTelegramApi(
+        accountId,
         telegramApi,
+      );
+      const resolvedUserId = await resolveAllowUserId({
+        telegramApi: tgApi,
         groupId,
         preferredUserId: userId,
       });
@@ -385,15 +504,21 @@ const registerTelegramRoutes = ({
         openclawDir: OPENCLAW_DIR,
         topicRegistry,
         groupId,
+        accountId,
         requireMention,
         resolvedUserId,
       });
 
       // Save metadata in local topic registry only.
-      if (groupName) {
-        topicRegistry.setGroup(groupId, { name: groupName });
-        syncPromptFiles();
-      }
+      const configPath = `${OPENCLAW_DIR}/openclaw.json`;
+      const cfg = JSON.parse(fs.readFileSync(configPath, "utf8"));
+      const boundAgentId = resolveBoundAgentIdForAccount({ cfg, accountId });
+      topicRegistry.setGroup(groupId, {
+        ...(groupName ? { name: groupName } : {}),
+        accountId,
+        ...(boundAgentId ? { agentId: boundAgentId } : {}),
+      });
+      syncPromptFiles();
       const syncWarning = await runTelegramGitSync("configure-group", groupId);
 
       res.json({ ok: true, userId: resolvedUserId || null, syncWarning });
@@ -410,47 +535,95 @@ const registerTelegramRoutes = ({
   // Workspace bootstrap info (lets UI jump straight to management)
   app.get("/api/telegram/workspace", async (req, res) => {
     try {
+      const accountId = resolveAccountId(req);
       const debugEnabled = isDebugEnabled();
       const configPath = `${OPENCLAW_DIR}/openclaw.json`;
       let cfg = JSON.parse(fs.readFileSync(configPath, "utf8"));
       let telegramConfig = cfg.channels?.telegram || {};
-      const configuredGroups = telegramConfig.groups || {};
+      const { accountConfig } = resolveTelegramConfigForAccount({
+        telegramConfig,
+        accountId,
+      });
+      const configuredGroups =
+        accountConfig?.groups && typeof accountConfig.groups === "object"
+          ? accountConfig.groups
+          : {};
       const groupIds = Object.keys(configuredGroups);
-      if (groupIds.length === 0) {
-        return res.json({ ok: true, configured: false, debugEnabled });
+      const registryFallbackGroups = topicRegistry.getGroupsForAccount(accountId);
+      const registryFallbackGroupIds = Object.keys(registryFallbackGroups);
+      const useRegistryFallback =
+        groupIds.length === 0 && registryFallbackGroupIds.length > 0;
+      if (groupIds.length === 0 && !useRegistryFallback) {
+        return res.json({
+          ok: true,
+          configured: false,
+          groups: [],
+          debugEnabled,
+        });
       }
-      const groupId = String(groupIds[0]);
-      const groupConfig = configuredGroups[groupId] || {};
-      const repairResult = await repairGroupAllowFromIfMissing({
-        cfg,
-        groupId,
-        requireMention: !!groupConfig.requireMention,
-      });
-      if (repairResult.repaired) {
-        cfg = JSON.parse(fs.readFileSync(configPath, "utf8"));
-        telegramConfig = cfg.channels?.telegram || {};
+
+      const tgApi = resolveAccountTelegramApi(accountId, telegramApi);
+      let activeGroupIds = useRegistryFallback ? registryFallbackGroupIds : groupIds;
+      if (!useRegistryFallback) {
+        let anyRepaired = false;
+        for (const gId of groupIds) {
+          const gConfig = configuredGroups[gId] || {};
+          const repairResult = await repairGroupAllowFromIfMissing({
+            cfg,
+            accountId,
+            groupId: gId,
+            requireMention: !!gConfig.requireMention,
+            tgApi,
+          });
+          if (repairResult.repaired) {
+            anyRepaired = true;
+          }
+        }
+        if (anyRepaired) {
+          cfg = JSON.parse(fs.readFileSync(configPath, "utf8"));
+          telegramConfig = cfg.channels?.telegram || {};
+        }
+        const refreshedAccountConfig = resolveTelegramConfigForAccount({
+          telegramConfig,
+          accountId,
+        }).accountConfig;
+        const refreshedGroups =
+          refreshedAccountConfig?.groups &&
+          typeof refreshedAccountConfig.groups === "object"
+            ? refreshedAccountConfig.groups
+            : {};
+        activeGroupIds = Object.keys(refreshedGroups);
       }
-      const registryGroup = topicRegistry.getGroup(groupId);
-      let groupName = registryGroup?.name || groupId;
-      try {
-        const chat = await telegramApi.getChat(groupId);
-        if (chat?.title) groupName = chat.title;
-      } catch {}
+
+      const groups = [];
+      for (const gId of activeGroupIds) {
+        const registryGroup = topicRegistry.getGroup(gId);
+        let gName = registryGroup?.name || gId;
+        try {
+          const chat = await tgApi.getChat(gId);
+          if (chat?.title) gName = chat.title;
+        } catch {}
+        groups.push({
+          groupId: gId,
+          groupName: gName,
+          topics: registryGroup?.topics || {},
+        });
+      }
+
+      const first = groups[0] || {};
       return res.json({
         ok: true,
         configured: true,
-        groupId,
-        groupName,
-        topics: registryGroup?.topics || {},
+        groups,
+        groupId: first.groupId,
+        groupName: first.groupName,
+        topics: first.topics,
         debugEnabled,
         concurrency: {
           agentMaxConcurrent: cfg.agents?.defaults?.maxConcurrent ?? null,
           subagentMaxConcurrent:
             cfg.agents?.defaults?.subagents?.maxConcurrent ?? null,
         },
-        repairedGroupAllowFrom: !!repairResult.repaired,
-        repairedUserId: repairResult.resolvedUserId || null,
-        syncWarning: repairResult.syncWarning || null,
       });
     } catch (e) {
       return res.json({ ok: false, error: e.message });
@@ -460,26 +633,49 @@ const registerTelegramRoutes = ({
   // Reset Telegram workspace onboarding state
   app.post("/api/telegram/workspace/reset", async (req, res) => {
     try {
+      const accountId = resolveAccountId(req);
       const configPath = `${OPENCLAW_DIR}/openclaw.json`;
       const cfg = JSON.parse(fs.readFileSync(configPath, "utf8"));
-      const telegramGroups = Object.keys(cfg.channels?.telegram?.groups || {});
-      if (cfg.channels?.telegram) {
-        delete cfg.channels.telegram.groups;
-        delete cfg.channels.telegram.groupAllowFrom;
+      const telegramConfig = cfg.channels?.telegram;
+      if (!telegramConfig || typeof telegramConfig !== "object") {
+        return res.json({ ok: true, syncWarning: null });
+      }
+      const { normalizedAccountId, hasAccounts, accountConfig } =
+        resolveTelegramConfigForAccount({
+          telegramConfig,
+          accountId,
+        });
+      const telegramGroups = Object.keys(accountConfig?.groups || {});
+      const groupsToRemove =
+        telegramGroups.length > 0
+          ? telegramGroups
+          : Object.keys(topicRegistry.getGroupsForAccount(accountId));
+      if (hasAccounts) {
+        const accountEntry = telegramConfig.accounts?.[normalizedAccountId];
+        if (accountEntry && typeof accountEntry === "object") {
+          delete accountEntry.groups;
+          delete accountEntry.groupAllowFrom;
+        }
+      } else {
+        delete telegramConfig.groups;
+        delete telegramConfig.groupAllowFrom;
       }
       fs.writeFileSync(configPath, JSON.stringify(cfg, null, 2));
 
       // Remove corresponding groups from topic registry
       const registry = topicRegistry.readRegistry();
       if (registry && registry.groups) {
-        for (const groupId of telegramGroups) {
+        for (const groupId of groupsToRemove) {
           delete registry.groups[groupId];
         }
         topicRegistry.writeRegistry(registry);
       }
 
       syncPromptFiles();
-      const syncWarning = await runTelegramGitSync("reset-workspace", "telegram");
+      const syncWarning = await runTelegramGitSync(
+        "reset-workspace",
+        "telegram",
+      );
       return res.json({ ok: true, syncWarning });
     } catch (e) {
       return res.json({ ok: false, error: e.message });

package/lib/server/telegram-workspace.js

@@ -2,11 +2,39 @@ const kTelegramTopicConcurrencyMultiplier = 3;
 const kAgentConcurrencyFloor = 8;
 const kSubagentConcurrencyFloor = 4;
 
+const normalizeAccountId = (value) => String(value || "").trim() || "default";
+
+const resolveTelegramAccountConfig = ({ telegramConfig, accountId }) => {
+  const normalizedAccountId = normalizeAccountId(accountId);
+  const accounts =
+    telegramConfig?.accounts && typeof telegramConfig.accounts === "object"
+      ? telegramConfig.accounts
+      : null;
+  const hasAccounts = !!accounts && Object.keys(accounts).length > 0;
+  if (hasAccounts) {
+    const nextAccountConfig =
+      accounts[normalizedAccountId] && typeof accounts[normalizedAccountId] === "object"
+        ? accounts[normalizedAccountId]
+        : {};
+    return {
+      normalizedAccountId,
+      hasAccounts,
+      accountConfig: nextAccountConfig,
+    };
+  }
+  return {
+    normalizedAccountId,
+    hasAccounts: false,
+    accountConfig: telegramConfig,
+  };
+};
+
 const syncConfigForTelegram = ({
   fs,
   openclawDir,
   topicRegistry,
   groupId,
+  accountId = "default",
   requireMention = false,
   resolvedUserId = "",
 }) => {
@@ -20,9 +48,32 @@ const syncConfigForTelegram = ({
 
   if (!cfg.channels) cfg.channels = {};
   if (!cfg.channels.telegram) cfg.channels.telegram = {};
-  if (!cfg.channels.telegram.groups) cfg.channels.telegram.groups = {};
-  const existingGroupConfig = cfg.channels.telegram.groups[groupId] || {};
-  cfg.channels.telegram.groups[groupId] = {
+  const telegramConfig = cfg.channels.telegram;
+  const { normalizedAccountId, hasAccounts, accountConfig } =
+    resolveTelegramAccountConfig({
+      telegramConfig,
+      accountId,
+    });
+  if (hasAccounts) {
+    if (!telegramConfig.accounts || typeof telegramConfig.accounts !== "object") {
+      telegramConfig.accounts = {};
+    }
+    if (
+      !telegramConfig.accounts[normalizedAccountId]
+      || typeof telegramConfig.accounts[normalizedAccountId] !== "object"
+    ) {
+      telegramConfig.accounts[normalizedAccountId] = {};
+    }
+  }
+  const targetConfig = hasAccounts
+    ? telegramConfig.accounts[normalizedAccountId]
+    : telegramConfig;
+
+  if (!targetConfig.groups || typeof targetConfig.groups !== "object") {
+    targetConfig.groups = {};
+  }
+  const existingGroupConfig = targetConfig.groups[groupId] || {};
+  targetConfig.groups[groupId] = {
     ...existingGroupConfig,
     requireMention,
   };
@@ -35,20 +86,20 @@ const syncConfigForTelegram = ({
     promptTopics[threadId] = { systemPrompt };
   }
   if (Object.keys(promptTopics).length > 0) {
-    cfg.channels.telegram.groups[groupId].topics = promptTopics;
+    targetConfig.groups[groupId].topics = promptTopics;
   } else {
-    delete cfg.channels.telegram.groups[groupId].topics;
+    delete targetConfig.groups[groupId].topics;
   }
 
-  cfg.channels.telegram.groupPolicy = "allowlist";
-  if (!Array.isArray(cfg.channels.telegram.groupAllowFrom)) {
-    cfg.channels.telegram.groupAllowFrom = [];
+  targetConfig.groupPolicy = "allowlist";
+  if (!Array.isArray(targetConfig.groupAllowFrom)) {
+    targetConfig.groupAllowFrom = [];
   }
   if (
     resolvedUserId
-    && !cfg.channels.telegram.groupAllowFrom.includes(String(resolvedUserId))
+    && !targetConfig.groupAllowFrom.includes(String(resolvedUserId))
   ) {
-    cfg.channels.telegram.groupAllowFrom.push(String(resolvedUserId));
+    targetConfig.groupAllowFrom.push(String(resolvedUserId));
   }
 
   // Persist thread sessions and keep concurrency in schema-valid agent defaults.