resolveInboundDebounceMs,

} from "openclaw/plugin-sdk/channel-inbound-debounce";

import { resolveStoredModelOverride } from "openclaw/plugin-sdk/command-auth";

import {

resolveCommandAuthorization,

resolveCommandAuthorizedFromAuthorizers,

} from "openclaw/plugin-sdk/command-auth-native";

import { resolveCommandAuthorizedFromAuthorizers } from "openclaw/plugin-sdk/command-auth-native";

import { buildCommandsMessagePaginated } from "openclaw/plugin-sdk/command-status";

import { replaceConfigFile } from "openclaw/plugin-sdk/config-mutation";

import type { DmPolicy, OpenClawConfig } from "openclaw/plugin-sdk/config-types";

resolveSessionStoreEntry,

updateSessionStore,

} from "openclaw/plugin-sdk/session-store-runtime";

import { expandTelegramAllowFromWithAccessGroups } from "./access-groups.js";

import {

expandTelegramAllowFromWithAccessGroups,

resolveTelegramDmAllow,

} from "./access-groups.js";

import { resolveTelegramAccount, resolveTelegramMediaRuntimeOptions } from "./accounts.js";

import { withTelegramApiErrorLogging } from "./api-logging.js";

import {

isSenderAllowed,

normalizeDmAllowFromWithStore,

resolveTelegramEffectiveDmPolicy,

type NormalizedAllowFrom,

} from "./bot-access.js";

import {

import { resolveMedia } from "./bot/delivery.resolve-media.js";

import {

getTelegramTextParts,

buildTelegramGroupFrom,

buildTelegramGroupPeerId,

buildTelegramParentPeer,

isTelegramCommandsAllowFromConfigured,

resolveTelegramCommandAuthorization,

resolveTelegramForumFlag,

resolveTelegramForumThreadId,

resolveTelegramGroupAllowFromContext,

readChannelAllowFromStore: telegramDeps.readChannelAllowFromStore,

resolveTelegramGroupConfig,

}));

// Use direct config dmPolicy override if available for DMs

const effectiveDmPolicy =

!params.isGroup &&

groupAllowContext.groupConfig &&

"dmPolicy" in groupAllowContext.groupConfig

? (groupAllowContext.groupConfig.dmPolicy ?? telegramCfg.dmPolicy ?? "pairing")

: (telegramCfg.dmPolicy ?? "pairing");

const effectiveDmPolicy = resolveTelegramEffectiveDmPolicy({

isGroup: params.isGroup,

groupConfig: groupAllowContext.groupConfig,

dmPolicy: telegramCfg.dmPolicy,

});

return { dmPolicy: effectiveDmPolicy, ...groupAllowContext };

};

const { chatId, isGroup, senderId, senderUsername, context, cfg } = params;

const useAccessGroups = cfg.commands?.useAccessGroups !== false;

const dmAllowFrom = context.groupAllowOverride ?? allowFrom;

const commandsAllowFrom = cfg.commands?.allowFrom;

const commandsAllowFromConfigured =

commandsAllowFrom != null &&

typeof commandsAllowFrom === "object" &&

(Array.isArray(commandsAllowFrom.telegram) || Array.isArray(commandsAllowFrom["*"]));

if (commandsAllowFromConfigured) {

return resolveCommandAuthorization({

ctx: {

Provider: "telegram",

Surface: "telegram",

OriginatingChannel: "telegram",

AccountId: accountId,

ChatType: isGroup ? "group" : "direct",

From: isGroup

? buildTelegramGroupFrom(chatId, context.resolvedThreadId)

: `telegram:${chatId}`,

SenderId: senderId || undefined,

SenderUsername: senderUsername || undefined,

},

if (isTelegramCommandsAllowFromConfigured(cfg)) {

return resolveTelegramCommandAuthorization({

cfg,

commandAuthorized: false,

accountId,

chatId,

isGroup,

resolvedThreadId: context.resolvedThreadId,

senderId,

senderUsername,

}).isAuthorizedSender;

}

});

};

// Handle emoji reactions to messages.

bot.on("message_reaction", async (ctx) => {

try {

const reaction = ctx.messageReaction;

const isGroup = reaction.chat.type === "group" || reaction.chat.type === "supergroup";

const isForum = reaction.chat.is_forum === true;

// Resolve reaction notification mode (default: "own").

const reactionMode = telegramCfg.reactionNotifications ?? "own";

if (reactionMode === "off") {

return;

}

}

// Detect added reactions.

const oldEmojis = new Set(

reaction.old_reaction

.filter((r): r is ReactionTypeEmoji => r.type === "emoji")

return;

}

// Build sender label.

const senderName = user

? [user.first_name, user.last_name].filter(Boolean).join(" ").trim() || user.username

: undefined;

: undefined;

const peerId = isGroup ? buildTelegramGroupPeerId(chatId, resolvedThreadId) : String(chatId);

const parentPeer = buildTelegramParentPeer({ isGroup, resolvedThreadId, chatId });

// Fresh config for bindings lookup; other routing inputs are payload-derived.

const route = resolveAgentRoute({

cfg: telegramDeps.getRuntimeConfig(),

channel: "telegram",

});

const sessionKey = route.sessionKey;

// Enqueue system event for each added reaction.

for (const r of addedReactions) {

const emoji = r.emoji;

const text = `Telegram reaction added: ${emoji} by ${senderLabel} on msg ${messageId}`;

oversizeLogMessage,

} = params;

// Text fragment handling - Telegram splits long pastes into multiple inbound messages (~4096 chars).

// We buffer “near-limit” messages and append immediately-following parts.

const text = typeof msg.text === "string" ? msg.text : undefined;

const isCommandLike = (text ?? "").trim().startsWith("/");

if (text && !isCommandLike) {

const nowMs = Date.now();

const senderId = msg.from?.id != null ? String(msg.from.id) : "unknown";

// Use resolvedThreadId for forum groups, dmThreadId for DM topics

const threadId = resolvedThreadId ?? dmThreadId;

const key = `text:${chatId}:${threadId ?? "main"}:${senderId}`;

const existing = textFragmentBuffer.get(key);

}

}

// Not appendable (or limits exceeded): flush buffered entry first, then continue normally.

clearTimeout(existing.timer);

textFragmentBuffer.delete(key);

textFragmentProcessing = textFragmentProcessing

}

}

// Media group handling - buffer multi-image messages

const mediaGroupId = msg.media_group_id;

if (mediaGroupId) {

const existing = mediaGroupBuffer.get(mediaGroupId);

return;

}

// Skip sticker-only messages where the sticker was skipped (animated/video)

// These have no media and no text content to process.

const hasText = Boolean(getTelegramTextParts(msg).text.trim());

if (msg.sticker && !media && !hasText) {

logVerbose("telegram: skipping sticker-only message (unsupported sticker type)");

typeof (ctx as { answerCallbackQuery?: unknown }).answerCallbackQuery === "function"

? () => ctx.answerCallbackQuery()

: () => bot.api.answerCallbackQuery(callback.id);

// Answer immediately to prevent Telegram from retrying while we process

await withTelegramApiErrorLogging({

operation: "answerCallbackQuery",

runtime,

return;

}

// Model selection callback handler (mdl_prov, mdl_list_*, mdl_sel_*, mdl_back)

const modelCallback = parseModelCallbackData(data);

if (modelCallback) {

if (

const { provider, page } = modelCallback;

const modelSet = byProvider.get(provider);

if (!modelSet || modelSet.size === 0) {

// Provider not found or no models - show providers list

const providerInfos: ProviderInfo[] = providers.map((p) => ({

id: p,

count: byProvider.get(p)?.size ?? 0,

const totalPages = calculateTotalPages(models.length, pageSize);

const safePage = Math.max(1, Math.min(page, totalPages));

// Resolve current model from session (prefer overrides)

const currentModel = sessionState.model;

const buttons = buildModelsKeyboard({

return;

}

// Directly set model override in session

try {

// Use the fresh runtimeCfg (loaded at callback entry) so store path

// and default-model resolution stay consistent with the next

throw new TelegramRetryableCallbackError(err);

}

// Update message to show success with visual feedback

const escapeHtml = (text: string) =>

text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");

const actionText = isDefaultSelection

}

});

// Handle group migration to supergroup (chat ID changes)

bot.on("message:migrate_to_chat_id", async (ctx) => {

try {

const msg = ctx.message;

return;

}

// Check if old chat ID has config and migrate it

const currentConfig = telegramDeps.getRuntimeConfig();

const migration = migrateTelegramGroupConfig({

cfg: currentConfig,

effectiveGroupAllow,

hasGroupAllowOverride,

} = eventAuthContext;

// For DMs, prefer per-DM/topic allowFrom (groupAllowOverride) over account-level allowFrom

const dmAllowFrom = groupAllowOverride ?? allowFrom;

const expandedDmAllowFrom = await expandTelegramAllowFromWithAccessGroups({

const dmAllow = await resolveTelegramDmAllow({

cfg,

allowFrom: dmAllowFrom,

groupAllowOverride,

allowFrom,

accountId,

senderId: event.senderId,

});

const effectiveDmAllow = normalizeDmAllowFromWithStore({

allowFrom: expandedDmAllowFrom,

storeAllowFrom,

dmPolicy,

});

dmPolicy,

msg: event.msg,

chatId: event.chatId,

effectiveDmAllow,

effectiveDmAllow: dmAllow.effectiveAllow,

accountId,

bot,

logger,

});

});

// Handle channel posts — enables bot-to-bot communication via Telegram channels.

// Telegram bots cannot see other bot messages in groups, but CAN in channels.

// This handler normalizes channel_post updates into the standard message pipeline.

bot.on("channel_post", async (ctx) => {

const post = ctx.channelPost;

if (!post) {