TelegramTopicConfig,

} from "openclaw/plugin-sdk/config-contracts";

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

import { resolveChannelContextVisibilityMode } from "openclaw/plugin-sdk/context-visibility-runtime";

import {

buildPluginBindingResolvedText,

parsePluginBindingApprovalCustomId,

import { resolveAgentRoute } from "openclaw/plugin-sdk/routing";

import { resolveThreadSessionKeys } from "openclaw/plugin-sdk/routing";

import { danger, logVerbose, warn } from "openclaw/plugin-sdk/runtime-env";

import { evaluateSupplementalContextVisibility } from "openclaw/plugin-sdk/security-runtime";

import {

getSessionEntry,

listSessionEntries,

patchSessionEntry,

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

import { normalizeStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";

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

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

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

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

import {

normalizeDmAllowFromWithStore,

firstDefined,

isSenderAllowed,

normalizeAllowFrom,

resolveTelegramEffectiveDmPolicy,

type NormalizedAllowFrom,

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

evaluateTelegramGroupBaseAccess,

evaluateTelegramGroupPolicyAccess,

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

import { resolveTelegramScopedGroupConfig } from "./group-config-helpers.js";

import { resolveTelegramGroupHistoryContextMode } from "./group-history-context.js";

import { migrateTelegramGroupConfig } from "./group-migration.js";

import {

const resolveReplyMediaForChain = async (

ctx: TelegramContext,

chain: TelegramCachedMessageNode[],

shouldHydrateMedia: (node: TelegramCachedMessageNode, index: number) => Promise<boolean>,

): Promise<{ replyMedia: TelegramMediaRef[]; replyChain: TelegramReplyChainEntry[] }> => {

const replyMedia: TelegramMediaRef[] = [];

const replyChain: TelegramReplyChainEntry[] = [];

for (const node of chain) {

for (const [index, node] of chain.entries()) {

let mediaRef: TelegramMediaRef | undefined;

const replyFileId = resolveInboundMediaFileId(node.sourceMessage);

if (replyFileId && hasInboundMedia(node.sourceMessage)) {

if (

replyFileId &&

hasInboundMedia(node.sourceMessage) &&

(await shouldHydrateMedia(node, index))

) {

try {

const media = await resolveMedia({

ctx: {

};

try {

const replyChainNodes = await buildReplyChainForMessage(params.msg);

const isGroupConversation =

params.msg.chat.type === "group" || params.msg.chat.type === "supergroup";

const runtimeCfg = telegramDeps.getRuntimeConfig();

const runtimeTelegramCfg = resolveTelegramAccount({ cfg: runtimeCfg, accountId }).config;

const isForum =

params.msg.chat.type === "supergroup" &&

Boolean(params.msg.chat.is_forum || params.msg.is_topic_message);

const scopedThreadId = resolveTelegramForumThreadId({

isForum,

messageThreadId: params.msg.message_thread_id,

});

const { groupConfig, topicConfig } = resolveTelegramScopedGroupConfig(

runtimeTelegramCfg,

params.msg.chat.id,

scopedThreadId,

);

const scopedAllowFrom = firstDefined(topicConfig?.allowFrom, groupConfig?.allowFrom);

const configuredGroupAllowFrom =

scopedAllowFrom ??

opts.groupAllowFrom ??

runtimeTelegramCfg.groupAllowFrom ??

runtimeTelegramCfg.allowFrom ??

opts.allowFrom;

const contextVisibilityMode = resolveChannelContextVisibilityMode({

cfg: runtimeCfg,

channel: "telegram",

accountId,

});

const shouldHydrateReplyMedia = async (

node: TelegramCachedMessageNode,

index: number,

): Promise<boolean> => {

if (!isGroupConversation) {

return true;

}

const expandedAllowFrom = await expandTelegramAllowFromWithAccessGroups({

cfg: runtimeCfg,

allowFrom: configuredGroupAllowFrom,

accountId,

senderId: node.senderId,

});

const effectiveAllow = normalizeAllowFrom(expandedAllowFrom);

const senderAllowed = effectiveAllow.hasEntries

? isSenderAllowed({

allow: effectiveAllow,

senderId: node.senderId,

senderUsername: node.senderUsername,

})

: true;

return evaluateSupplementalContextVisibility({

mode: contextVisibilityMode,

kind: index === 0 ? "quote" : "thread",

senderAllowed,

}).include;

};

const { replyMedia, replyChain } = await resolveReplyMediaForChain(

params.ctx,

replyChainNodes,

shouldHydrateReplyMedia,

);

const promptContextMediaByMessageId = new Map<string, TelegramMediaRef>();

const currentMessageId =

path: currentPromptMediaPath,

});

}

const isGroupConversation =

params.msg.chat.type === "group" || params.msg.chat.type === "supergroup";

if (!isGroupConversation) {

for (const entry of replyChain) {

const promptMediaPath = entry.mediaPath

? resolveTelegramPromptMediaPath(entry.mediaPath)

: undefined;

if (entry.messageId && entry.mediaPath && promptMediaPath) {

promptContextMediaByMessageId.set(entry.messageId, {

path: promptMediaPath,

...(entry.mediaType ? { contentType: entry.mediaType } : {}),

});

}

for (const entry of replyChain) {

const promptMediaPath = entry.mediaPath

? resolveTelegramPromptMediaPath(entry.mediaPath)

: undefined;

if (entry.messageId && entry.mediaPath && promptMediaPath) {

promptContextMediaByMessageId.set(entry.messageId, {

path: promptMediaPath,

...(entry.mediaType ? { contentType: entry.mediaType } : {}),

});

}

}

const promptContext = await buildPromptContextForMessage(