@fased/fased 0.1.41 → 0.1.43

package/dist/plugin-sdk/monitor-B1PUtkd6.js

@@ -0,0 +1,4539 @@
+import { $ as buildModelsKeyboard, $t as formatReasoningMessage, A as clearHistoryEntriesIfEnabled, Bn as resolveTelegramInlineButtonsScope, C as buildPairingReply, Cn as readJsonBodyWithLimit, E as DEFAULT_GROUP_HISTORY_LIMIT, Et as resolveChannelConfigWrites, F as removeAckReactionAfterReply, G as resolveEnvelopeFormatOptions, Gn as createDedupeCache, H as resolveInboundDebounceMs, I as shouldAckReaction, Jt as isAbortRequestText, Kt as hasControlCommand, N as recordPendingHistoryEntryIfEnabled, O as buildPendingHistoryContextFromMap, P as recordInboundSession, Pt as registerUnhandledRejectionHandler, Q as formatModelsAvailableHeader, R as dispatchReplyWithBufferedBlockDispatcher, St as formatDurationPrecise, T as sleepWithAbort, U as formatInboundEnvelope, V as createInboundDebouncer, Wn as waitForAbortSignal, X as resolveStoredModelOverride, Xt as matchesMentionWithExplicit, Yt as buildMentionRegexes, Z as buildModelsProviderData, b as logInboundDrop, bt as buildCommandsMessagePaginated, c as loadModelCatalog, er as resolveCommandAuthorizedFromAuthorizers, et as buildProviderKeyboard, f as createTypingCallbacks, it as buildCommandsPaginationKeyboard, l as modelSupportsVision, m as resolveMentionGatingWithBypass, nn as findCodeRegions, nt as getModelsPageSize, rn as isInsideCode, rt as parseModelCallbackData, s as findModelInCatalog, tn as stripReasoningTagsFromText, tr as resolveControlCommandGate, tt as calculateTotalPages, w as computeBackoff, wt as enqueueSystemEvent, x as logTypingFailure, y as logAckFailure } from "./pi-embedded-runner-DMfkIj60.js";
+import { C as recordSessionMetaFromInbound, Gn as getPluginCommandSpecs, S as readSessionUpdatedAt, Wn as executePluginCommand, _n as resolveChannelGroupRequireMention, gn as resolveChannelGroupPolicy, in as resolveTelegramAccount, qn as matchPluginCommand, x as loadSessionStore } from "./runtime-BUpqjZNM.js";
+import { i as defaultRuntime, r as createNonExitingRuntime, t as createSubsystemLogger } from "./subsystem-DBPNbQDQ.js";
+import { i as logVerbose, l as warn, p as getChildLogger, s as shouldLogVerbose, t as danger } from "./globals-B_jjtAje.js";
+import { s as resolveStateDir } from "./paths-BEmvSyOV.js";
+import "./utils-CYk9EKoq.js";
+import { Lt as resolveAgentMaxConcurrent, Yt as resolveDefaultModelForAgent, _ as TELEGRAM_COMMAND_NAME_PATTERN, fr as formatErrorMessage, n as loadConfig, pr as formatUncaughtError, s as writeConfigFile, v as normalizeTelegramCommandName, y as resolveTelegramCustomCommands } from "./config-DKNrb8oT.js";
+import { a as resolveAgentDir, u as resolveDefaultAgentId } from "./agent-scope-BbgPlhtw.js";
+import { p as normalizeAccountId$1, u as resolveThreadSessionKeys } from "./session-key-HSJ2KQTc.js";
+import "./accounts-RHZyaB73.js";
+import "./accounts-CuqIKU8X.js";
+import "./logger-BbFvCoKk.js";
+import "./exec-DQ8j4Fm3.js";
+import "./accounts-Bz_2QZSt.js";
+import "./allow-list-yqasgPpz.js";
+import "./redact-CwCz68Mi.js";
+import "./github-copilot-token-Dgug856m.js";
+import { n as retryAsync } from "./retry-DycQ4ymF.js";
+import { l as resolveStorePath } from "./paths-B88DQEK8.js";
+import "./ip-BkeyFRJr.js";
+import "./ssrf-D_4q0mKh.js";
+import "./fetch-guard-CxXvFYq5.js";
+import "./send-DGUAXb2b.js";
+import { a as resolveOpenProviderRuntimeGroupPolicy } from "./links-D5ecKoG9.js";
+import { C as isSenderAllowed, D as formatLocationText, E as resolveSenderAllowMatch, O as toLocationContext, P as firstDefined, S as resolveTelegramThreadSpec, T as normalizeDmAllowFromWithStore, _ as resolveTelegramForumThreadId, a as buildSenderLabel, b as resolveTelegramReplyId, c as buildTelegramGroupPeerId, d as buildTypingThreadParams, f as describeReplyTarget, g as normalizeForwardedContext, h as hasBotMention, i as buildGroupLabel, l as buildTelegramParentPeer, m as extractTelegramLocation, o as buildSenderName, p as expandTextLinks, s as buildTelegramGroupFrom, u as buildTelegramThreadParams, v as resolveTelegramGroupAllowFromContext, w as normalizeAllowFrom, x as resolveTelegramStreamMode, y as resolveTelegramMediaPlaceholder } from "./wsl-Cw-xOsqF.js";
+import { a as upsertChannelPairingRequest, n as readChannelAllowFromStore } from "./pairing-store-BdOcH_GA.js";
+import { c as resolveChunkMode, i as chunkMarkdownTextWithMode, l as resolveTextChunkLimit } from "./chunk-CuJIMshx.js";
+import { a as resolveAckReaction, n as createReplyPrefixOptions } from "./reply-prefix-CbPHNXlm.js";
+import "./tokens-Do_JU4Rh.js";
+import "./device-pairing-J1IH1jFl.js";
+import "./pairing-token-HQpaqod5.js";
+import { c as logWebhookError, d as startDiagnosticHeartbeat, f as stopDiagnosticHeartbeat, l as logWebhookProcessed, m as isDiagnosticsEnabled, u as logWebhookReceived } from "./diagnostic-C16gioN6.js";
+import "./diagnostic-session-state-B-9PL5r7.js";
+import "./optional-runtime-dependency-Bt_3Yigu.js";
+import { p as isGifMedia, v as mediaKindFromMime } from "./image-ops-BSQmb-17.js";
+import "./wallet-status-CdxTkLWz.js";
+import "./pi-model-discovery-DQdXL_-F.js";
+import "./runtime-dependency-pUwxUAJp.js";
+import "./ws-CxmRDbD9.js";
+import "./path-alias-guards-BlIJ0AmG.js";
+import "./fs-safe-DztQeyQe.js";
+import { n as resolveMarkdownTableMode } from "./markdown-tables-DrB-IM8r.js";
+import { a as fetchRemoteMedia, i as MediaFetchError, n as loadWebMedia, u as getAgentScopedMediaLocalRoots } from "./media-D8pWjqEt.js";
+import "./send-DWB5HFdb.js";
+import { a as saveMediaBuffer } from "./outbound-attachment-C9oadpUP.js";
+import "./fetch-RV7QDF43.js";
+import "./thread-bindings.state-DYYR9qeT.js";
+import "./memory-search-DHSeU4pJ.js";
+import "./manager-DQ1dH8OM.js";
+import "./query-expansion-BM7lmqaP.js";
+import "./common-C90EHP1w.js";
+import { C as isNativeCommandsExplicitlyDisabled, E as resolveNativeSkillsEnabled, T as resolveNativeCommandsEnabled, c as listNativeCommandSpecsForConfig, d as parseCommandArgs, p as resolveCommandArgMenu, r as findCommandByNativeName, s as listNativeCommandSpecs, t as buildCommandTextFromArgs, u as normalizeCommandBody } from "./commands-registry-DwQIFJmL.js";
+import { n as listSkillCommandsForAgents } from "./skill-commands-DCnCOVR_.js";
+import { t as finalizeInboundContext } from "./inbound-context-BNCTzgjG.js";
+import "./directory-live-G7AN8y8N.js";
+import "./targets-BgSHco9b.js";
+import "./sandbox-paths-fc-HFGJr.js";
+import { n as resolveAgentRoute } from "./resolve-route-wp5xq4Ws.js";
+import "./render-K7NwXvVu.js";
+import "./tables-DX84FwPB.js";
+import { n as recordChannelActivity } from "./channel-activity-B7MIaDei.js";
+import "./retry-policy-BTH89onl.js";
+import { _ as splitTelegramCaption, d as isRecoverableTelegramNetworkError, f as markdownToTelegramChunks, g as resolveTelegramFetch, h as wrapFileReferencesInHtml, i as editMessageTelegram, l as resolveTelegramVoiceSend, m as renderTelegramHtmlText, p as markdownToTelegramHtml, t as buildInlineKeyboard, u as wasSentByBot, v as withTelegramApiErrorLogging } from "./send-CRI83FPV.js";
+import { t as makeProxyFetch } from "./proxy-R5TjOIFS.js";
+import { i as getCachedSticker, n as describeStickerImage, t as cacheSticker } from "./sticker-cache-D4Ljzv1P.js";
+import { i as createStatusReactionController, n as DEFAULT_EMOJIS, t as createFinalizableDraftLifecycle } from "./draft-stream-controls-DGYBMJYc.js";
+import path from "node:path";
+import os from "node:os";
+import fs from "node:fs/promises";
+import crypto from "node:crypto";
+import { createServer } from "node:http";
+import { API_CONSTANTS, Bot, GrammyError, InputFile, webhookCallback } from "grammy";
+import { run, sequentialize } from "@grammyjs/runner";
+import { apiThrottler } from "@grammyjs/transformer-throttler";
+
+//#region src/telegram/allowed-updates.ts
+function resolveTelegramAllowedUpdates() {
+	const updates = [...API_CONSTANTS.DEFAULT_UPDATE_TYPES];
+	if (!updates.includes("message_reaction")) updates.push("message_reaction");
+	if (!updates.includes("channel_post")) updates.push("channel_post");
+	return updates;
+}
+
+//#endregion
+//#region src/telegram/bot-updates.ts
+const MEDIA_GROUP_TIMEOUT_MS = 500;
+const RECENT_TELEGRAM_UPDATE_TTL_MS = 5 * 6e4;
+const RECENT_TELEGRAM_UPDATE_MAX = 2e3;
+const resolveTelegramUpdateId = (ctx) => ctx.update?.update_id ?? ctx.update_id;
+const buildTelegramUpdateKey = (ctx) => {
+	const updateId = resolveTelegramUpdateId(ctx);
+	if (typeof updateId === "number") return `update:${updateId}`;
+	const callbackId = ctx.callbackQuery?.id;
+	if (callbackId) return `callback:${callbackId}`;
+	const msg = ctx.message ?? ctx.channelPost ?? ctx.editedChannelPost ?? ctx.update?.message ?? ctx.update?.edited_message ?? ctx.update?.channel_post ?? ctx.update?.edited_channel_post ?? ctx.callbackQuery?.message;
+	const chatId = msg?.chat?.id;
+	const messageId = msg?.message_id;
+	if (typeof chatId !== "undefined" && typeof messageId === "number") return `message:${chatId}:${messageId}`;
+};
+const createTelegramUpdateDedupe = () => createDedupeCache({
+	ttlMs: RECENT_TELEGRAM_UPDATE_TTL_MS,
+	maxSize: RECENT_TELEGRAM_UPDATE_MAX
+});
+
+//#endregion
+//#region src/telegram/bot/delivery.ts
+const PARSE_ERR_RE = /can't parse entities|parse entities|find end of the entity/i;
+const EMPTY_TEXT_ERR_RE = /message text is empty/i;
+const VOICE_FORBIDDEN_RE = /VOICE_MESSAGES_FORBIDDEN/;
+const FILE_TOO_BIG_RE = /file is too big/i;
+const TELEGRAM_MEDIA_SSRF_POLICY = {
+	allowedHostnames: ["api.telegram.org"],
+	allowRfc2544BenchmarkRange: true
+};
+async function deliverReplies(params) {
+	const { replies, chatId, runtime, bot, replyToMode, textLimit, thread, linkPreview, replyQuoteText } = params;
+	const chunkMode = params.chunkMode ?? "length";
+	let hasReplied = false;
+	let hasDelivered = false;
+	const markDelivered = () => {
+		hasDelivered = true;
+	};
+	const chunkText = (markdown) => {
+		const markdownChunks = chunkMode === "newline" ? chunkMarkdownTextWithMode(markdown, textLimit, chunkMode) : [markdown];
+		const chunks = [];
+		for (const chunk of markdownChunks) {
+			const nested = markdownToTelegramChunks(chunk, textLimit, { tableMode: params.tableMode });
+			if (!nested.length && chunk) {
+				chunks.push({
+					html: wrapFileReferencesInHtml(markdownToTelegramHtml(chunk, {
+						tableMode: params.tableMode,
+						wrapFileRefs: false
+					})),
+					text: chunk
+				});
+				continue;
+			}
+			chunks.push(...nested);
+		}
+		return chunks;
+	};
+	for (const reply of replies) {
+		const hasMedia = Boolean(reply?.mediaUrl) || (reply?.mediaUrls?.length ?? 0) > 0;
+		if (!reply?.text && !hasMedia) {
+			if (reply?.audioAsVoice) {
+				logVerbose("telegram reply has audioAsVoice without media/text; skipping");
+				continue;
+			}
+			runtime.error?.(danger("reply missing text/media"));
+			continue;
+		}
+		const replyToId = replyToMode === "off" ? void 0 : resolveTelegramReplyId(reply.replyToId);
+		const replyToMessageIdForPayload = replyToId && (replyToMode === "all" || !hasReplied) ? replyToId : void 0;
+		const mediaList = reply.mediaUrls?.length ? reply.mediaUrls : reply.mediaUrl ? [reply.mediaUrl] : [];
+		const telegramData = reply.channelData?.telegram;
+		const replyMarkup = buildInlineKeyboard(telegramData?.buttons);
+		if (mediaList.length === 0) {
+			const chunks = chunkText(reply.text || "");
+			let sentTextChunk = false;
+			for (let i = 0; i < chunks.length; i += 1) {
+				const chunk = chunks[i];
+				if (!chunk) continue;
+				const shouldAttachButtons = i === 0 && replyMarkup;
+				const chunkReplyToMessageId = replyToMode === "all" || i === 0 ? replyToMessageIdForPayload : void 0;
+				await sendTelegramText(bot, chatId, chunk.html, runtime, {
+					replyToMessageId: chunkReplyToMessageId,
+					replyQuoteText,
+					thread,
+					textMode: "html",
+					plainText: chunk.text,
+					linkPreview,
+					replyMarkup: shouldAttachButtons ? replyMarkup : void 0
+				});
+				sentTextChunk = true;
+				markDelivered();
+			}
+			if (replyToMessageIdForPayload && !hasReplied && sentTextChunk) hasReplied = true;
+			continue;
+		}
+		let first = true;
+		let pendingFollowUpText;
+		for (const mediaUrl of mediaList) {
+			const isFirstMedia = first;
+			const media = await loadWebMedia(mediaUrl, { localRoots: params.mediaLocalRoots });
+			const kind = mediaKindFromMime(media.contentType ?? void 0);
+			const isGif = isGifMedia({
+				contentType: media.contentType,
+				fileName: media.fileName
+			});
+			const fileName = media.fileName ?? (isGif ? "animation.gif" : "file");
+			const file = new InputFile(media.buffer, fileName);
+			const { caption, followUpText } = splitTelegramCaption(isFirstMedia ? reply.text ?? void 0 : void 0);
+			const htmlCaption = caption ? renderTelegramHtmlText(caption, { tableMode: params.tableMode }) : void 0;
+			if (followUpText) pendingFollowUpText = followUpText;
+			first = false;
+			const replyToMessageId = replyToMode === "all" || isFirstMedia ? replyToMessageIdForPayload : void 0;
+			const shouldAttachButtonsToMedia = isFirstMedia && replyMarkup && !followUpText;
+			const mediaParams = {
+				caption: htmlCaption,
+				...htmlCaption ? { parse_mode: "HTML" } : {},
+				...shouldAttachButtonsToMedia ? { reply_markup: replyMarkup } : {},
+				...buildTelegramSendParams({
+					replyToMessageId,
+					thread
+				})
+			};
+			if (isGif) {
+				await withTelegramApiErrorLogging({
+					operation: "sendAnimation",
+					runtime,
+					fn: () => bot.api.sendAnimation(chatId, file, { ...mediaParams })
+				});
+				markDelivered();
+			} else if (kind === "image") {
+				await withTelegramApiErrorLogging({
+					operation: "sendPhoto",
+					runtime,
+					fn: () => bot.api.sendPhoto(chatId, file, { ...mediaParams })
+				});
+				markDelivered();
+			} else if (kind === "video") {
+				await withTelegramApiErrorLogging({
+					operation: "sendVideo",
+					runtime,
+					fn: () => bot.api.sendVideo(chatId, file, { ...mediaParams })
+				});
+				markDelivered();
+			} else if (kind === "audio") {
+				const { useVoice } = resolveTelegramVoiceSend({
+					wantsVoice: reply.audioAsVoice === true,
+					contentType: media.contentType,
+					fileName,
+					logFallback: logVerbose
+				});
+				if (useVoice) {
+					await params.onVoiceRecording?.();
+					try {
+						await withTelegramApiErrorLogging({
+							operation: "sendVoice",
+							runtime,
+							shouldLog: (err) => !isVoiceMessagesForbidden(err),
+							fn: () => bot.api.sendVoice(chatId, file, { ...mediaParams })
+						});
+						markDelivered();
+					} catch (voiceErr) {
+						if (isVoiceMessagesForbidden(voiceErr)) {
+							const fallbackText = reply.text;
+							if (!fallbackText || !fallbackText.trim()) throw voiceErr;
+							logVerbose("telegram sendVoice forbidden (recipient has voice messages blocked in privacy settings); falling back to text");
+							await sendTelegramVoiceFallbackText({
+								bot,
+								chatId,
+								runtime,
+								text: fallbackText,
+								chunkText,
+								replyToId: replyToMessageIdForPayload,
+								replyToMode,
+								thread,
+								linkPreview,
+								replyMarkup,
+								replyQuoteText
+							});
+							if (replyToMessageIdForPayload && !hasReplied) hasReplied = true;
+							markDelivered();
+							continue;
+						}
+						throw voiceErr;
+					}
+				} else {
+					await withTelegramApiErrorLogging({
+						operation: "sendAudio",
+						runtime,
+						fn: () => bot.api.sendAudio(chatId, file, { ...mediaParams })
+					});
+					markDelivered();
+				}
+			} else {
+				await withTelegramApiErrorLogging({
+					operation: "sendDocument",
+					runtime,
+					fn: () => bot.api.sendDocument(chatId, file, { ...mediaParams })
+				});
+				markDelivered();
+			}
+			if (replyToMessageId && !hasReplied) hasReplied = true;
+			if (pendingFollowUpText && isFirstMedia) {
+				const chunks = chunkText(pendingFollowUpText);
+				for (let i = 0; i < chunks.length; i += 1) {
+					const chunk = chunks[i];
+					const followUpReplyToMessageId = replyToMode === "all" ? replyToMessageIdForPayload : void 0;
+					await sendTelegramText(bot, chatId, chunk.html, runtime, {
+						replyToMessageId: followUpReplyToMessageId,
+						thread,
+						textMode: "html",
+						plainText: chunk.text,
+						linkPreview,
+						replyMarkup: i === 0 ? replyMarkup : void 0
+					});
+					markDelivered();
+				}
+				pendingFollowUpText = void 0;
+			}
+			if (replyToMessageIdForPayload && !hasReplied) hasReplied = true;
+		}
+	}
+	return { delivered: hasDelivered };
+}
+async function resolveMedia(ctx, maxBytes, token, proxyFetch) {
+	const msg = ctx.message;
+	const downloadAndSaveTelegramFile = async (filePath, fetchImpl) => {
+		const fetched = await fetchRemoteMedia({
+			url: `https://api.telegram.org/file/bot${token}/${filePath}`,
+			fetchImpl,
+			filePathHint: filePath,
+			maxBytes,
+			ssrfPolicy: TELEGRAM_MEDIA_SSRF_POLICY
+		});
+		const originalName = fetched.fileName ?? filePath;
+		return saveMediaBuffer(fetched.buffer, fetched.contentType, "inbound", maxBytes, originalName);
+	};
+	if (msg.sticker) {
+		const sticker = msg.sticker;
+		if (sticker.is_animated || sticker.is_video) {
+			logVerbose("telegram: skipping animated/video sticker (only static stickers supported)");
+			return null;
+		}
+		if (!sticker.file_id) return null;
+		try {
+			const file = await ctx.getFile();
+			if (!file.file_path) {
+				logVerbose("telegram: getFile returned no file_path for sticker");
+				return null;
+			}
+			const fetchImpl = proxyFetch ?? globalThis.fetch;
+			if (!fetchImpl) {
+				logVerbose("telegram: fetch not available for sticker download");
+				return null;
+			}
+			const saved = await downloadAndSaveTelegramFile(file.file_path, fetchImpl);
+			const cached = sticker.file_unique_id ? getCachedSticker(sticker.file_unique_id) : null;
+			if (cached) {
+				logVerbose(`telegram: sticker cache hit for ${sticker.file_unique_id}`);
+				const fileId = sticker.file_id ?? cached.fileId;
+				const emoji = sticker.emoji ?? cached.emoji;
+				const setName = sticker.set_name ?? cached.setName;
+				if (fileId !== cached.fileId || emoji !== cached.emoji || setName !== cached.setName) cacheSticker({
+					...cached,
+					fileId,
+					emoji,
+					setName
+				});
+				return {
+					path: saved.path,
+					contentType: saved.contentType,
+					placeholder: "<media:sticker>",
+					stickerMetadata: {
+						emoji,
+						setName,
+						fileId,
+						fileUniqueId: sticker.file_unique_id,
+						cachedDescription: cached.description
+					}
+				};
+			}
+			return {
+				path: saved.path,
+				contentType: saved.contentType,
+				placeholder: "<media:sticker>",
+				stickerMetadata: {
+					emoji: sticker.emoji ?? void 0,
+					setName: sticker.set_name ?? void 0,
+					fileId: sticker.file_id,
+					fileUniqueId: sticker.file_unique_id
+				}
+			};
+		} catch (err) {
+			logVerbose(`telegram: failed to process sticker: ${String(err)}`);
+			return null;
+		}
+	}
+	if (!(msg.photo?.[msg.photo.length - 1] ?? msg.video ?? msg.video_note ?? msg.document ?? msg.audio ?? msg.voice)?.file_id) return null;
+	let file;
+	try {
+		file = await retryAsync(() => ctx.getFile(), {
+			attempts: 3,
+			minDelayMs: 1e3,
+			maxDelayMs: 4e3,
+			jitter: .2,
+			label: "telegram:getFile",
+			shouldRetry: isRetryableGetFileError,
+			onRetry: ({ attempt, maxAttempts }) => logVerbose(`telegram: getFile retry ${attempt}/${maxAttempts}`)
+		});
+	} catch (err) {
+		if (isFileTooBigError(err)) {
+			logVerbose(warn("telegram: getFile failed - file exceeds Telegram Bot API 20MB limit; skipping attachment"));
+			return null;
+		}
+		logVerbose(`telegram: getFile failed after retries: ${String(err)}`);
+		return null;
+	}
+	if (!file.file_path) throw new Error("Telegram getFile returned no file_path");
+	const fetchImpl = proxyFetch ?? globalThis.fetch;
+	if (!fetchImpl) throw new Error("fetch is not available; set channels.telegram.proxy in config");
+	const saved = await downloadAndSaveTelegramFile(file.file_path, fetchImpl);
+	const placeholder = resolveTelegramMediaPlaceholder(msg) ?? "<media:document>";
+	return {
+		path: saved.path,
+		contentType: saved.contentType,
+		placeholder
+	};
+}
+function isVoiceMessagesForbidden(err) {
+	if (err instanceof GrammyError) return VOICE_FORBIDDEN_RE.test(err.description);
+	return VOICE_FORBIDDEN_RE.test(formatErrorMessage(err));
+}
+/**
+* Returns true if the error is Telegram's "file is too big" error.
+* This happens when trying to download files >20MB via the Bot API.
+* Unlike network errors, this is a permanent error and should not be retried.
+*/
+function isFileTooBigError(err) {
+	if (err instanceof GrammyError) return FILE_TOO_BIG_RE.test(err.description);
+	return FILE_TOO_BIG_RE.test(formatErrorMessage(err));
+}
+/**
+* Returns true if the error is a transient network error that should be retried.
+* Returns false for permanent errors like "file is too big" (400 Bad Request).
+*/
+function isRetryableGetFileError(err) {
+	if (isFileTooBigError(err)) return false;
+	return true;
+}
+async function sendTelegramVoiceFallbackText(opts) {
+	const chunks = opts.chunkText(opts.text);
+	for (let i = 0; i < chunks.length; i += 1) {
+		const chunk = chunks[i];
+		const chunkReplyToId = opts.replyToMode === "all" || i === 0 ? opts.replyToId : void 0;
+		await sendTelegramText(opts.bot, opts.chatId, chunk.html, opts.runtime, {
+			replyToMessageId: chunkReplyToId,
+			replyQuoteText: opts.replyQuoteText,
+			thread: opts.thread,
+			textMode: "html",
+			plainText: chunk.text,
+			linkPreview: opts.linkPreview,
+			replyMarkup: i === 0 ? opts.replyMarkup : void 0
+		});
+	}
+}
+function buildTelegramSendParams(opts) {
+	const threadParams = buildTelegramThreadParams(opts?.thread);
+	const params = {};
+	if (opts?.replyToMessageId) params.reply_to_message_id = opts.replyToMessageId;
+	if (threadParams) params.message_thread_id = threadParams.message_thread_id;
+	return params;
+}
+async function sendTelegramText(bot, chatId, text, runtime, opts) {
+	const baseParams = buildTelegramSendParams({
+		replyToMessageId: opts?.replyToMessageId,
+		thread: opts?.thread
+	});
+	const linkPreviewOptions = opts?.linkPreview ?? true ? void 0 : { is_disabled: true };
+	const htmlText = (opts?.textMode ?? "markdown") === "html" ? text : markdownToTelegramHtml(text);
+	const fallbackText = opts?.plainText ?? text;
+	const hasFallbackText = fallbackText.trim().length > 0;
+	const sendPlainFallback = async () => {
+		const res = await withTelegramApiErrorLogging({
+			operation: "sendMessage",
+			runtime,
+			fn: () => bot.api.sendMessage(chatId, fallbackText, {
+				...linkPreviewOptions ? { link_preview_options: linkPreviewOptions } : {},
+				...opts?.replyMarkup ? { reply_markup: opts.replyMarkup } : {},
+				...baseParams
+			})
+		});
+		runtime.log?.(`telegram sendMessage ok chat=${chatId} message=${res.message_id} (plain)`);
+		return res.message_id;
+	};
+	if (!htmlText.trim()) {
+		if (!hasFallbackText) throw new Error("telegram sendMessage failed: empty formatted text and empty plain fallback");
+		return await sendPlainFallback();
+	}
+	try {
+		const res = await withTelegramApiErrorLogging({
+			operation: "sendMessage",
+			runtime,
+			shouldLog: (err) => {
+				const errText = formatErrorMessage(err);
+				return !PARSE_ERR_RE.test(errText) && !EMPTY_TEXT_ERR_RE.test(errText);
+			},
+			fn: () => bot.api.sendMessage(chatId, htmlText, {
+				parse_mode: "HTML",
+				...linkPreviewOptions ? { link_preview_options: linkPreviewOptions } : {},
+				...opts?.replyMarkup ? { reply_markup: opts.replyMarkup } : {},
+				...baseParams
+			})
+		});
+		runtime.log?.(`telegram sendMessage ok chat=${chatId} message=${res.message_id}`);
+		return res.message_id;
+	} catch (err) {
+		const errText = formatErrorMessage(err);
+		if (PARSE_ERR_RE.test(errText) || EMPTY_TEXT_ERR_RE.test(errText)) {
+			if (!hasFallbackText) throw err;
+			runtime.log?.(`telegram formatted send failed; retrying without formatting: ${errText}`);
+			return await sendPlainFallback();
+		}
+		throw err;
+	}
+}
+
+//#endregion
+//#region src/telegram/dm-access.ts
+function resolveTelegramSenderIdentity(msg, chatId) {
+	const from = msg.from;
+	const userId = from?.id != null ? String(from.id) : null;
+	return {
+		username: from?.username ?? "",
+		userId,
+		candidateId: userId ?? String(chatId),
+		firstName: from?.first_name,
+		lastName: from?.last_name
+	};
+}
+async function enforceTelegramDmAccess(params) {
+	const { isGroup, dmPolicy, msg, chatId, effectiveDmAllow, accountId, bot, logger } = params;
+	if (isGroup) return true;
+	if (dmPolicy === "disabled") return false;
+	if (dmPolicy === "open") return true;
+	const sender = resolveTelegramSenderIdentity(msg, chatId);
+	const allowMatch = resolveSenderAllowMatch({
+		allow: effectiveDmAllow,
+		senderId: sender.candidateId,
+		senderUsername: sender.username
+	});
+	const allowMatchMeta = `matchKey=${allowMatch.matchKey ?? "none"} matchSource=${allowMatch.matchSource ?? "none"}`;
+	if (effectiveDmAllow.hasWildcard || effectiveDmAllow.hasEntries && allowMatch.allowed) return true;
+	if (dmPolicy === "pairing") {
+		try {
+			const telegramUserId = sender.userId ?? sender.candidateId;
+			const { code, created } = await upsertChannelPairingRequest({
+				channel: "telegram",
+				id: telegramUserId,
+				accountId,
+				meta: {
+					username: sender.username || void 0,
+					firstName: sender.firstName,
+					lastName: sender.lastName
+				}
+			});
+			if (created) {
+				logger.info({
+					chatId: String(chatId),
+					senderUserId: sender.userId ?? void 0,
+					username: sender.username || void 0,
+					firstName: sender.firstName,
+					lastName: sender.lastName,
+					matchKey: allowMatch.matchKey ?? "none",
+					matchSource: allowMatch.matchSource ?? "none"
+				}, "telegram pairing request");
+				await withTelegramApiErrorLogging({
+					operation: "sendMessage",
+					fn: () => bot.api.sendMessage(chatId, buildPairingReply({
+						channel: "telegram",
+						idLine: `Your Telegram user id: ${telegramUserId}`,
+						code
+					}))
+				});
+			}
+		} catch (err) {
+			logVerbose(`telegram pairing reply failed for chat ${chatId}: ${String(err)}`);
+		}
+		return false;
+	}
+	logVerbose(`Blocked unauthorized telegram sender ${sender.candidateId} (dmPolicy=${dmPolicy}, ${allowMatchMeta})`);
+	return false;
+}
+
+//#endregion
+//#region src/telegram/group-access.ts
+const evaluateTelegramGroupBaseAccess = (params) => {
+	if (!params.isGroup) return { allowed: true };
+	if (params.groupConfig?.enabled === false) return {
+		allowed: false,
+		reason: "group-disabled"
+	};
+	if (params.topicConfig?.enabled === false) return {
+		allowed: false,
+		reason: "topic-disabled"
+	};
+	if (!params.enforceAllowOverride || !params.hasGroupAllowOverride) return { allowed: true };
+	if (!params.effectiveGroupAllow.hasEntries) return {
+		allowed: false,
+		reason: "group-override-unauthorized"
+	};
+	const senderId = params.senderId ?? "";
+	if (params.requireSenderForAllowOverride && !senderId) return {
+		allowed: false,
+		reason: "group-override-unauthorized"
+	};
+	if (!isSenderAllowed({
+		allow: params.effectiveGroupAllow,
+		senderId,
+		senderUsername: params.senderUsername ?? ""
+	})) return {
+		allowed: false,
+		reason: "group-override-unauthorized"
+	};
+	return { allowed: true };
+};
+const resolveTelegramRuntimeGroupPolicy = (params) => resolveOpenProviderRuntimeGroupPolicy({
+	providerConfigPresent: params.providerConfigPresent,
+	groupPolicy: params.groupPolicy,
+	defaultGroupPolicy: params.defaultGroupPolicy
+});
+const evaluateTelegramGroupPolicyAccess = (params) => {
+	const { groupPolicy: runtimeFallbackPolicy } = resolveTelegramRuntimeGroupPolicy({
+		providerConfigPresent: params.cfg.channels?.telegram !== void 0,
+		groupPolicy: params.telegramCfg.groupPolicy,
+		defaultGroupPolicy: params.cfg.channels?.defaults?.groupPolicy
+	});
+	const fallbackPolicy = firstDefined(params.telegramCfg.groupPolicy, params.cfg.channels?.defaults?.groupPolicy) ?? runtimeFallbackPolicy;
+	const groupPolicy = params.useTopicAndGroupOverrides ? firstDefined(params.topicConfig?.groupPolicy, params.groupConfig?.groupPolicy, params.telegramCfg.groupPolicy, params.cfg.channels?.defaults?.groupPolicy) ?? runtimeFallbackPolicy : fallbackPolicy;
+	if (!params.isGroup || !params.enforcePolicy) return {
+		allowed: true,
+		groupPolicy
+	};
+	if (groupPolicy === "disabled") return {
+		allowed: false,
+		reason: "group-policy-disabled",
+		groupPolicy
+	};
+	if (groupPolicy === "allowlist" && params.enforceAllowlistAuthorization) {
+		const senderId = params.senderId ?? "";
+		if (params.requireSenderForAllowlistAuthorization && !senderId) return {
+			allowed: false,
+			reason: "group-policy-allowlist-no-sender",
+			groupPolicy
+		};
+		if (!params.allowEmptyAllowlistEntries && !params.effectiveGroupAllow.hasEntries) return {
+			allowed: false,
+			reason: "group-policy-allowlist-empty",
+			groupPolicy
+		};
+		const senderUsername = params.senderUsername ?? "";
+		if (!isSenderAllowed({
+			allow: params.effectiveGroupAllow,
+			senderId,
+			senderUsername
+		})) return {
+			allowed: false,
+			reason: "group-policy-allowlist-unauthorized",
+			groupPolicy
+		};
+	}
+	if (params.checkChatAllowlist) {
+		const groupAllowlist = params.resolveGroupPolicy(params.chatId);
+		if (groupAllowlist.allowlistEnabled && !groupAllowlist.allowed) return {
+			allowed: false,
+			reason: "group-chat-not-allowed",
+			groupPolicy
+		};
+	}
+	return {
+		allowed: true,
+		groupPolicy
+	};
+};
+
+//#endregion
+//#region src/telegram/group-migration.ts
+function resolveAccountGroups(cfg, accountId) {
+	if (!accountId) return {};
+	const normalized = normalizeAccountId$1(accountId);
+	const accounts = cfg.channels?.telegram?.accounts;
+	if (!accounts || typeof accounts !== "object") return {};
+	const exact = accounts[normalized];
+	if (exact?.groups) return { groups: exact.groups };
+	const matchKey = Object.keys(accounts).find((key) => key.toLowerCase() === normalized.toLowerCase());
+	return { groups: matchKey ? accounts[matchKey]?.groups : void 0 };
+}
+function migrateTelegramGroupsInPlace(groups, oldChatId, newChatId) {
+	if (!groups) return {
+		migrated: false,
+		skippedExisting: false
+	};
+	if (oldChatId === newChatId) return {
+		migrated: false,
+		skippedExisting: false
+	};
+	if (!Object.hasOwn(groups, oldChatId)) return {
+		migrated: false,
+		skippedExisting: false
+	};
+	if (Object.hasOwn(groups, newChatId)) return {
+		migrated: false,
+		skippedExisting: true
+	};
+	groups[newChatId] = groups[oldChatId];
+	delete groups[oldChatId];
+	return {
+		migrated: true,
+		skippedExisting: false
+	};
+}
+function migrateTelegramGroupConfig(params) {
+	const scopes = [];
+	let migrated = false;
+	let skippedExisting = false;
+	const migrationTargets = [{
+		scope: "account",
+		groups: resolveAccountGroups(params.cfg, params.accountId).groups
+	}, {
+		scope: "global",
+		groups: params.cfg.channels?.telegram?.groups
+	}];
+	for (const target of migrationTargets) {
+		const result = migrateTelegramGroupsInPlace(target.groups, params.oldChatId, params.newChatId);
+		if (result.migrated) {
+			migrated = true;
+			scopes.push(target.scope);
+		}
+		if (result.skippedExisting) skippedExisting = true;
+	}
+	return {
+		migrated,
+		skippedExisting,
+		scopes
+	};
+}
+
+//#endregion
+//#region src/telegram/bot-handlers.ts
+function isMediaSizeLimitError(err) {
+	const errMsg = String(err);
+	return errMsg.includes("exceeds") && errMsg.includes("MB limit");
+}
+function isRecoverableMediaGroupError(err) {
+	return err instanceof MediaFetchError || isMediaSizeLimitError(err);
+}
+function hasInboundMedia(msg) {
+	return Boolean(msg.media_group_id) || Array.isArray(msg.photo) && msg.photo.length > 0 || Boolean(msg.video ?? msg.video_note ?? msg.document ?? msg.audio ?? msg.voice ?? msg.sticker);
+}
+function hasReplyTargetMedia(msg) {
+	const externalReply = msg.external_reply;
+	const replyTarget = msg.reply_to_message ?? externalReply;
+	return Boolean(replyTarget && hasInboundMedia(replyTarget));
+}
+function resolveInboundMediaFileId(msg) {
+	return msg.sticker?.file_id ?? msg.photo?.[msg.photo.length - 1]?.file_id ?? msg.video?.file_id ?? msg.video_note?.file_id ?? msg.document?.file_id ?? msg.audio?.file_id ?? msg.voice?.file_id;
+}
+const registerTelegramHandlers = ({ cfg, accountId, bot, opts, runtime, mediaMaxBytes, telegramCfg, allowFrom, groupAllowFrom, resolveGroupPolicy, resolveTelegramGroupConfig, shouldSkipUpdate, processMessage, logger }) => {
+	const DEFAULT_TEXT_FRAGMENT_MAX_GAP_MS = 1500;
+	const TELEGRAM_TEXT_FRAGMENT_START_THRESHOLD_CHARS = 4e3;
+	const TELEGRAM_TEXT_FRAGMENT_MAX_GAP_MS = typeof opts.testTimings?.textFragmentGapMs === "number" && Number.isFinite(opts.testTimings.textFragmentGapMs) ? Math.max(10, Math.floor(opts.testTimings.textFragmentGapMs)) : DEFAULT_TEXT_FRAGMENT_MAX_GAP_MS;
+	const TELEGRAM_TEXT_FRAGMENT_MAX_ID_GAP = 1;
+	const TELEGRAM_TEXT_FRAGMENT_MAX_PARTS = 12;
+	const TELEGRAM_TEXT_FRAGMENT_MAX_TOTAL_CHARS = 5e4;
+	const mediaGroupTimeoutMs = typeof opts.testTimings?.mediaGroupFlushMs === "number" && Number.isFinite(opts.testTimings.mediaGroupFlushMs) ? Math.max(10, Math.floor(opts.testTimings.mediaGroupFlushMs)) : MEDIA_GROUP_TIMEOUT_MS;
+	const mediaGroupBuffer = /* @__PURE__ */ new Map();
+	let mediaGroupProcessing = Promise.resolve();
+	const textFragmentBuffer = /* @__PURE__ */ new Map();
+	let textFragmentProcessing = Promise.resolve();
+	const debounceMs = resolveInboundDebounceMs({
+		cfg,
+		channel: "telegram"
+	});
+	const FORWARD_BURST_DEBOUNCE_MS = 80;
+	const resolveTelegramDebounceLane = (msg) => {
+		const forwardMeta = msg;
+		return forwardMeta.forward_origin ?? forwardMeta.forward_from ?? forwardMeta.forward_from_chat ?? forwardMeta.forward_sender_name ?? forwardMeta.forward_date ? "forward" : "default";
+	};
+	const buildSyntheticTextMessage = (params) => ({
+		...params.base,
+		...params.from ? { from: params.from } : {},
+		text: params.text,
+		caption: void 0,
+		caption_entities: void 0,
+		entities: void 0,
+		...params.date != null ? { date: params.date } : {}
+	});
+	const buildSyntheticContext = (ctx, message) => {
+		const getFile = typeof ctx.getFile === "function" ? ctx.getFile.bind(ctx) : async () => ({});
+		return {
+			message,
+			me: ctx.me,
+			getFile
+		};
+	};
+	const inboundDebouncer = createInboundDebouncer({
+		debounceMs,
+		resolveDebounceMs: (entry) => entry.debounceLane === "forward" ? FORWARD_BURST_DEBOUNCE_MS : debounceMs,
+		buildKey: (entry) => entry.debounceKey,
+		shouldDebounce: (entry) => {
+			const text = entry.msg.text ?? entry.msg.caption ?? "";
+			const hasText = text.trim().length > 0;
+			if (hasText && hasControlCommand(text, cfg, { botUsername: entry.botUsername })) return false;
+			if (entry.debounceLane === "forward") return true;
+			return entry.allMedia.length === 0 && hasText;
+		},
+		onFlush: async (entries) => {
+			const last = entries.at(-1);
+			if (!last) return;
+			if (entries.length === 1) {
+				const replyMedia = await resolveReplyMediaForMessage(last.ctx, last.msg);
+				await processMessage(last.ctx, last.allMedia, last.storeAllowFrom, void 0, replyMedia);
+				return;
+			}
+			const combinedText = entries.map((entry) => entry.msg.text ?? entry.msg.caption ?? "").filter(Boolean).join("\n");
+			const combinedMedia = entries.flatMap((entry) => entry.allMedia);
+			if (!combinedText.trim() && combinedMedia.length === 0) return;
+			const first = entries[0];
+			const baseCtx = first.ctx;
+			const syntheticMessage = buildSyntheticTextMessage({
+				base: first.msg,
+				text: combinedText,
+				date: last.msg.date ?? first.msg.date
+			});
+			const messageIdOverride = last.msg.message_id ? String(last.msg.message_id) : void 0;
+			const syntheticCtx = buildSyntheticContext(baseCtx, syntheticMessage);
+			const replyMedia = await resolveReplyMediaForMessage(baseCtx, syntheticMessage);
+			await processMessage(syntheticCtx, combinedMedia, first.storeAllowFrom, messageIdOverride ? { messageIdOverride } : void 0, replyMedia);
+		},
+		onError: (err) => {
+			runtime.error?.(danger(`telegram debounce flush failed: ${String(err)}`));
+		}
+	});
+	const resolveTelegramSessionState = (params) => {
+		const resolvedThreadId = params.resolvedThreadId ?? resolveTelegramForumThreadId({
+			isForum: params.isForum,
+			messageThreadId: params.messageThreadId
+		});
+		const peerId = params.isGroup ? buildTelegramGroupPeerId(params.chatId, resolvedThreadId) : String(params.chatId);
+		const parentPeer = buildTelegramParentPeer({
+			isGroup: params.isGroup,
+			resolvedThreadId,
+			chatId: params.chatId
+		});
+		const route = resolveAgentRoute({
+			cfg,
+			channel: "telegram",
+			accountId,
+			peer: {
+				kind: params.isGroup ? "group" : "direct",
+				id: peerId
+			},
+			parentPeer
+		});
+		const baseSessionKey = route.sessionKey;
+		const dmThreadId = !params.isGroup ? params.messageThreadId : void 0;
+		const sessionKey = (dmThreadId != null ? resolveThreadSessionKeys({
+			baseSessionKey,
+			threadId: String(dmThreadId)
+		}) : null)?.sessionKey ?? baseSessionKey;
+		const store = loadSessionStore(resolveStorePath(cfg.session?.store, { agentId: route.agentId }));
+		const entry = store[sessionKey];
+		const storedOverride = resolveStoredModelOverride({
+			sessionEntry: entry,
+			sessionStore: store,
+			sessionKey
+		});
+		if (storedOverride) return {
+			agentId: route.agentId,
+			sessionEntry: entry,
+			model: storedOverride.provider ? `${storedOverride.provider}/${storedOverride.model}` : storedOverride.model
+		};
+		const provider = entry?.modelProvider?.trim();
+		const model = entry?.model?.trim();
+		if (provider && model) return {
+			agentId: route.agentId,
+			sessionEntry: entry,
+			model: `${provider}/${model}`
+		};
+		const modelCfg = cfg.agents?.defaults?.model;
+		return {
+			agentId: route.agentId,
+			sessionEntry: entry,
+			model: typeof modelCfg === "string" ? modelCfg : modelCfg?.primary
+		};
+	};
+	const processMediaGroup = async (entry) => {
+		try {
+			entry.messages.sort((a, b) => a.msg.message_id - b.msg.message_id);
+			const primaryEntry = entry.messages.find((m) => m.msg.caption || m.msg.text) ?? entry.messages[0];
+			const allMedia = [];
+			for (const { ctx } of entry.messages) {
+				let media;
+				try {
+					media = await resolveMedia(ctx, mediaMaxBytes, opts.token, opts.proxyFetch);
+				} catch (mediaErr) {
+					if (!isRecoverableMediaGroupError(mediaErr)) throw mediaErr;
+					runtime.log?.(warn(`media group: skipping photo that failed to fetch: ${String(mediaErr)}`));
+					continue;
+				}
+				if (media) allMedia.push({
+					path: media.path,
+					contentType: media.contentType,
+					stickerMetadata: media.stickerMetadata
+				});
+			}
+			const storeAllowFrom = await loadStoreAllowFrom();
+			const replyMedia = await resolveReplyMediaForMessage(primaryEntry.ctx, primaryEntry.msg);
+			await processMessage(primaryEntry.ctx, allMedia, storeAllowFrom, void 0, replyMedia);
+		} catch (err) {
+			runtime.error?.(danger(`media group handler failed: ${String(err)}`));
+		}
+	};
+	const flushTextFragments = async (entry) => {
+		try {
+			entry.messages.sort((a, b) => a.msg.message_id - b.msg.message_id);
+			const first = entry.messages[0];
+			const last = entry.messages.at(-1);
+			if (!first || !last) return;
+			const combinedText = entry.messages.map((m) => m.msg.text ?? "").join("");
+			if (!combinedText.trim()) return;
+			const syntheticMessage = buildSyntheticTextMessage({
+				base: first.msg,
+				text: combinedText,
+				date: last.msg.date ?? first.msg.date
+			});
+			const storeAllowFrom = await loadStoreAllowFrom();
+			const baseCtx = first.ctx;
+			await processMessage(buildSyntheticContext(baseCtx, syntheticMessage), [], storeAllowFrom, { messageIdOverride: String(last.msg.message_id) });
+		} catch (err) {
+			runtime.error?.(danger(`text fragment handler failed: ${String(err)}`));
+		}
+	};
+	const queueTextFragmentFlush = async (entry) => {
+		textFragmentProcessing = textFragmentProcessing.then(async () => {
+			await flushTextFragments(entry);
+		}).catch(() => void 0);
+		await textFragmentProcessing;
+	};
+	const runTextFragmentFlush = async (entry) => {
+		textFragmentBuffer.delete(entry.key);
+		await queueTextFragmentFlush(entry);
+	};
+	const scheduleTextFragmentFlush = (entry) => {
+		clearTimeout(entry.timer);
+		entry.timer = setTimeout(async () => {
+			await runTextFragmentFlush(entry);
+		}, TELEGRAM_TEXT_FRAGMENT_MAX_GAP_MS);
+	};
+	const loadStoreAllowFrom = async () => readChannelAllowFromStore("telegram", process.env, accountId).catch(() => []);
+	const resolveReplyMediaForMessage = async (ctx, msg) => {
+		const replyMessage = msg.reply_to_message;
+		if (!replyMessage || !hasInboundMedia(replyMessage)) return [];
+		const replyFileId = resolveInboundMediaFileId(replyMessage);
+		if (!replyFileId) return [];
+		try {
+			const media = await resolveMedia({
+				message: replyMessage,
+				me: ctx.me,
+				getFile: async () => await bot.api.getFile(replyFileId)
+			}, mediaMaxBytes, opts.token, opts.proxyFetch);
+			if (!media) return [];
+			return [{
+				path: media.path,
+				contentType: media.contentType,
+				stickerMetadata: media.stickerMetadata
+			}];
+		} catch (err) {
+			logger.warn({
+				chatId: msg.chat.id,
+				error: String(err)
+			}, "reply media fetch failed");
+			return [];
+		}
+	};
+	const isAllowlistAuthorized = (allow, senderId, senderUsername) => allow.hasWildcard || allow.hasEntries && isSenderAllowed({
+		allow,
+		senderId,
+		senderUsername
+	});
+	const shouldSkipGroupMessage = (params) => {
+		const { isGroup, chatId, chatTitle, resolvedThreadId, senderId, senderUsername, effectiveGroupAllow, hasGroupAllowOverride, groupConfig, topicConfig } = params;
+		const baseAccess = evaluateTelegramGroupBaseAccess({
+			isGroup,
+			groupConfig,
+			topicConfig,
+			hasGroupAllowOverride,
+			effectiveGroupAllow,
+			senderId,
+			senderUsername,
+			enforceAllowOverride: true,
+			requireSenderForAllowOverride: true
+		});
+		if (!baseAccess.allowed) {
+			if (baseAccess.reason === "group-disabled") {
+				logVerbose(`Blocked telegram group ${chatId} (group disabled)`);
+				return true;
+			}
+			if (baseAccess.reason === "topic-disabled") {
+				logVerbose(`Blocked telegram topic ${chatId} (${resolvedThreadId ?? "unknown"}) (topic disabled)`);
+				return true;
+			}
+			logVerbose(`Blocked telegram group sender ${senderId || "unknown"} (group allowFrom override)`);
+			return true;
+		}
+		if (!isGroup) return false;
+		const policyAccess = evaluateTelegramGroupPolicyAccess({
+			isGroup,
+			chatId,
+			cfg,
+			telegramCfg,
+			topicConfig,
+			groupConfig,
+			effectiveGroupAllow,
+			senderId,
+			senderUsername,
+			resolveGroupPolicy,
+			enforcePolicy: true,
+			useTopicAndGroupOverrides: true,
+			enforceAllowlistAuthorization: true,
+			allowEmptyAllowlistEntries: false,
+			requireSenderForAllowlistAuthorization: true,
+			checkChatAllowlist: true
+		});
+		if (!policyAccess.allowed) {
+			if (policyAccess.reason === "group-policy-disabled") {
+				logVerbose("Blocked telegram group message (groupPolicy: disabled)");
+				return true;
+			}
+			if (policyAccess.reason === "group-policy-allowlist-no-sender") {
+				logVerbose("Blocked telegram group message (no sender ID, groupPolicy: allowlist)");
+				return true;
+			}
+			if (policyAccess.reason === "group-policy-allowlist-empty") {
+				logVerbose("Blocked telegram group message (groupPolicy: allowlist, no group allowlist entries)");
+				return true;
+			}
+			if (policyAccess.reason === "group-policy-allowlist-unauthorized") {
+				logVerbose(`Blocked telegram group message from ${senderId} (groupPolicy: allowlist)`);
+				return true;
+			}
+			logger.info({
+				chatId,
+				title: chatTitle,
+				reason: "not-allowed"
+			}, "skipping group message");
+			return true;
+		}
+		return false;
+	};
+	const TELEGRAM_EVENT_AUTH_RULES = {
+		reaction: {
+			enforceDirectAuthorization: true,
+			enforceGroupAllowlistAuthorization: false,
+			deniedDmReason: "reaction unauthorized by dm policy/allowlist",
+			deniedGroupReason: "reaction unauthorized by group allowlist"
+		},
+		"callback-scope": {
+			enforceDirectAuthorization: false,
+			enforceGroupAllowlistAuthorization: false,
+			deniedDmReason: "callback unauthorized by inlineButtonsScope",
+			deniedGroupReason: "callback unauthorized by inlineButtonsScope"
+		},
+		"callback-allowlist": {
+			enforceDirectAuthorization: true,
+			enforceGroupAllowlistAuthorization: false,
+			deniedDmReason: "callback unauthorized by inlineButtonsScope allowlist",
+			deniedGroupReason: "callback unauthorized by inlineButtonsScope allowlist"
+		}
+	};
+	const resolveTelegramEventAuthorizationContext = async (params) => {
+		return {
+			dmPolicy: telegramCfg.dmPolicy ?? "pairing",
+			...params.groupAllowContext ?? await resolveTelegramGroupAllowFromContext({
+				chatId: params.chatId,
+				accountId,
+				isForum: params.isForum,
+				messageThreadId: params.messageThreadId,
+				groupAllowFrom,
+				resolveTelegramGroupConfig
+			})
+		};
+	};
+	const authorizeTelegramEventSender = (params) => {
+		const { chatId, chatTitle, isGroup, senderId, senderUsername, mode, context } = params;
+		const { dmPolicy, resolvedThreadId, storeAllowFrom, groupConfig, topicConfig, effectiveGroupAllow, hasGroupAllowOverride } = context;
+		const { enforceDirectAuthorization, enforceGroupAllowlistAuthorization, deniedDmReason, deniedGroupReason } = TELEGRAM_EVENT_AUTH_RULES[mode];
+		if (shouldSkipGroupMessage({
+			isGroup,
+			chatId,
+			chatTitle,
+			resolvedThreadId,
+			senderId,
+			senderUsername,
+			effectiveGroupAllow,
+			hasGroupAllowOverride,
+			groupConfig,
+			topicConfig
+		})) return {
+			allowed: false,
+			reason: "group-policy"
+		};
+		if (!isGroup && enforceDirectAuthorization) {
+			if (dmPolicy === "disabled") {
+				logVerbose(`Blocked telegram direct event from ${senderId || "unknown"} (${deniedDmReason})`);
+				return {
+					allowed: false,
+					reason: "direct-disabled"
+				};
+			}
+			if (dmPolicy !== "open") {
+				if (!isAllowlistAuthorized(normalizeDmAllowFromWithStore({
+					allowFrom,
+					storeAllowFrom,
+					dmPolicy
+				}), senderId, senderUsername)) {
+					logVerbose(`Blocked telegram direct sender ${senderId || "unknown"} (${deniedDmReason})`);
+					return {
+						allowed: false,
+						reason: "direct-unauthorized"
+					};
+				}
+			}
+		}
+		if (isGroup && enforceGroupAllowlistAuthorization) {
+			if (!isAllowlistAuthorized(effectiveGroupAllow, senderId, senderUsername)) {
+				logVerbose(`Blocked telegram group sender ${senderId || "unknown"} (${deniedGroupReason})`);
+				return {
+					allowed: false,
+					reason: "group-unauthorized"
+				};
+			}
+		}
+		return { allowed: true };
+	};
+	bot.on("message_reaction", async (ctx) => {
+		try {
+			const reaction = ctx.messageReaction;
+			if (!reaction) return;
+			if (shouldSkipUpdate(ctx)) return;
+			const chatId = reaction.chat.id;
+			const messageId = reaction.message_id;
+			const user = reaction.user;
+			const senderId = user?.id != null ? String(user.id) : "";
+			const senderUsername = user?.username ?? "";
+			const isGroup = reaction.chat.type === "group" || reaction.chat.type === "supergroup";
+			const isForum = reaction.chat.is_forum === true;
+			const reactionMode = telegramCfg.reactionNotifications ?? "own";
+			if (reactionMode === "off") return;
+			if (user?.is_bot) return;
+			if (reactionMode === "own" && !wasSentByBot(chatId, messageId)) return;
+			const eventAuthContext = await resolveTelegramEventAuthorizationContext({
+				chatId,
+				isForum
+			});
+			if (!authorizeTelegramEventSender({
+				chatId,
+				chatTitle: reaction.chat.title,
+				isGroup,
+				senderId,
+				senderUsername,
+				mode: "reaction",
+				context: eventAuthContext
+			}).allowed) return;
+			const oldEmojis = new Set(reaction.old_reaction.filter((r) => r.type === "emoji").map((r) => r.emoji));
+			const addedReactions = reaction.new_reaction.filter((r) => r.type === "emoji").filter((r) => !oldEmojis.has(r.emoji));
+			if (addedReactions.length === 0) return;
+			const senderName = user ? [user.first_name, user.last_name].filter(Boolean).join(" ").trim() || user.username : void 0;
+			const senderUsernameLabel = user?.username ? `@${user.username}` : void 0;
+			let senderLabel = senderName;
+			if (senderName && senderUsernameLabel) senderLabel = `${senderName} (${senderUsernameLabel})`;
+			else if (!senderName && senderUsernameLabel) senderLabel = senderUsernameLabel;
+			if (!senderLabel && user?.id) senderLabel = `id:${user.id}`;
+			senderLabel = senderLabel || "unknown";
+			const resolvedThreadId = isForum ? resolveTelegramForumThreadId({
+				isForum,
+				messageThreadId: void 0
+			}) : void 0;
+			const peerId = isGroup ? buildTelegramGroupPeerId(chatId, resolvedThreadId) : String(chatId);
+			const parentPeer = buildTelegramParentPeer({
+				isGroup,
+				resolvedThreadId,
+				chatId
+			});
+			const sessionKey = resolveAgentRoute({
+				cfg: loadConfig(),
+				channel: "telegram",
+				accountId,
+				peer: {
+					kind: isGroup ? "group" : "direct",
+					id: peerId
+				},
+				parentPeer
+			}).sessionKey;
+			for (const r of addedReactions) {
+				const emoji = r.emoji;
+				const text = `Telegram reaction added: ${emoji} by ${senderLabel} on msg ${messageId}`;
+				enqueueSystemEvent(text, {
+					sessionKey,
+					contextKey: `telegram:reaction:add:${chatId}:${messageId}:${user?.id ?? "anon"}:${emoji}`
+				});
+				logVerbose(`telegram: reaction event enqueued: ${text}`);
+			}
+		} catch (err) {
+			runtime.error?.(danger(`telegram reaction handler failed: ${String(err)}`));
+		}
+	});
+	const processInboundMessage = async (params) => {
+		const { ctx, msg, chatId, resolvedThreadId, storeAllowFrom, sendOversizeWarning, oversizeLogMessage } = params;
+		const text = typeof msg.text === "string" ? msg.text : void 0;
+		const isCommandLike = (text ?? "").trim().startsWith("/");
+		if (text && !isCommandLike) {
+			const nowMs = Date.now();
+			const senderId = msg.from?.id != null ? String(msg.from.id) : "unknown";
+			const key = `text:${chatId}:${resolvedThreadId ?? "main"}:${senderId}`;
+			const existing = textFragmentBuffer.get(key);
+			if (existing) {
+				const last = existing.messages.at(-1);
+				const lastMsgId = last?.msg.message_id;
+				const lastReceivedAtMs = last?.receivedAtMs ?? nowMs;
+				const idGap = typeof lastMsgId === "number" ? msg.message_id - lastMsgId : Infinity;
+				const timeGapMs = nowMs - lastReceivedAtMs;
+				if (idGap > 0 && idGap <= TELEGRAM_TEXT_FRAGMENT_MAX_ID_GAP && timeGapMs >= 0 && timeGapMs <= TELEGRAM_TEXT_FRAGMENT_MAX_GAP_MS) {
+					const nextTotalChars = existing.messages.reduce((sum, m) => sum + (m.msg.text?.length ?? 0), 0) + text.length;
+					if (existing.messages.length + 1 <= TELEGRAM_TEXT_FRAGMENT_MAX_PARTS && nextTotalChars <= TELEGRAM_TEXT_FRAGMENT_MAX_TOTAL_CHARS) {
+						existing.messages.push({
+							msg,
+							ctx,
+							receivedAtMs: nowMs
+						});
+						scheduleTextFragmentFlush(existing);
+						return;
+					}
+				}
+				clearTimeout(existing.timer);
+				textFragmentBuffer.delete(key);
+				textFragmentProcessing = textFragmentProcessing.then(async () => {
+					await flushTextFragments(existing);
+				}).catch(() => void 0);
+				await textFragmentProcessing;
+			}
+			if (text.length >= TELEGRAM_TEXT_FRAGMENT_START_THRESHOLD_CHARS) {
+				const entry = {
+					key,
+					messages: [{
+						msg,
+						ctx,
+						receivedAtMs: nowMs
+					}],
+					timer: setTimeout(() => {}, TELEGRAM_TEXT_FRAGMENT_MAX_GAP_MS)
+				};
+				textFragmentBuffer.set(key, entry);
+				scheduleTextFragmentFlush(entry);
+				return;
+			}
+		}
+		const mediaGroupId = msg.media_group_id;
+		if (mediaGroupId) {
+			const existing = mediaGroupBuffer.get(mediaGroupId);
+			if (existing) {
+				clearTimeout(existing.timer);
+				existing.messages.push({
+					msg,
+					ctx
+				});
+				existing.timer = setTimeout(async () => {
+					mediaGroupBuffer.delete(mediaGroupId);
+					mediaGroupProcessing = mediaGroupProcessing.then(async () => {
+						await processMediaGroup(existing);
+					}).catch(() => void 0);
+					await mediaGroupProcessing;
+				}, mediaGroupTimeoutMs);
+			} else {
+				const entry = {
+					messages: [{
+						msg,
+						ctx
+					}],
+					timer: setTimeout(async () => {
+						mediaGroupBuffer.delete(mediaGroupId);
+						mediaGroupProcessing = mediaGroupProcessing.then(async () => {
+							await processMediaGroup(entry);
+						}).catch(() => void 0);
+						await mediaGroupProcessing;
+					}, mediaGroupTimeoutMs)
+				};
+				mediaGroupBuffer.set(mediaGroupId, entry);
+			}
+			return;
+		}
+		let media = null;
+		try {
+			media = await resolveMedia(ctx, mediaMaxBytes, opts.token, opts.proxyFetch);
+		} catch (mediaErr) {
+			if (isMediaSizeLimitError(mediaErr)) {
+				if (sendOversizeWarning) {
+					const limitMb = Math.round(mediaMaxBytes / (1024 * 1024));
+					await withTelegramApiErrorLogging({
+						operation: "sendMessage",
+						runtime,
+						fn: () => bot.api.sendMessage(chatId, `⚠️ File too large. Maximum size is ${limitMb}MB.`, { reply_to_message_id: msg.message_id })
+					}).catch(() => {});
+				}
+				logger.warn({
+					chatId,
+					error: String(mediaErr)
+				}, oversizeLogMessage);
+				return;
+			}
+			logger.warn({
+				chatId,
+				error: String(mediaErr)
+			}, "media fetch failed");
+			await withTelegramApiErrorLogging({
+				operation: "sendMessage",
+				runtime,
+				fn: () => bot.api.sendMessage(chatId, "⚠️ Failed to download media. Please try again.", { reply_to_message_id: msg.message_id })
+			}).catch(() => {});
+			return;
+		}
+		const hasText = Boolean((msg.text ?? msg.caption ?? "").trim());
+		if (msg.sticker && !media && !hasText) {
+			logVerbose("telegram: skipping sticker-only message (unsupported sticker type)");
+			return;
+		}
+		const allMedia = media ? [{
+			path: media.path,
+			contentType: media.contentType,
+			stickerMetadata: media.stickerMetadata
+		}] : [];
+		const senderId = msg.from?.id ? String(msg.from.id) : "";
+		const conversationKey = resolvedThreadId != null ? `${chatId}:topic:${resolvedThreadId}` : String(chatId);
+		const debounceLane = resolveTelegramDebounceLane(msg);
+		const debounceKey = senderId ? `telegram:${accountId ?? "default"}:${conversationKey}:${senderId}:${debounceLane}` : null;
+		await inboundDebouncer.enqueue({
+			ctx,
+			msg,
+			allMedia,
+			storeAllowFrom,
+			debounceKey,
+			debounceLane,
+			botUsername: ctx.me?.username
+		});
+	};
+	bot.on("callback_query", async (ctx) => {
+		const callback = ctx.callbackQuery;
+		if (!callback) return;
+		if (shouldSkipUpdate(ctx)) return;
+		await withTelegramApiErrorLogging({
+			operation: "answerCallbackQuery",
+			runtime,
+			fn: typeof ctx.answerCallbackQuery === "function" ? () => ctx.answerCallbackQuery() : () => bot.api.answerCallbackQuery(callback.id)
+		}).catch(() => {});
+		try {
+			const data = (callback.data ?? "").trim();
+			const callbackMessage = callback.message;
+			if (!data || !callbackMessage) return;
+			const editCallbackMessage = async (text, params) => {
+				if (typeof ctx.editMessageText === "function") return await ctx.editMessageText(text, params);
+				return await bot.api.editMessageText(callbackMessage.chat.id, callbackMessage.message_id, text, params);
+			};
+			const deleteCallbackMessage = async () => {
+				if (typeof ctx.deleteMessage === "function") return await ctx.deleteMessage();
+				return await bot.api.deleteMessage(callbackMessage.chat.id, callbackMessage.message_id);
+			};
+			const replyToCallbackChat = async (text, params) => {
+				if (typeof ctx.reply === "function") return await ctx.reply(text, params);
+				return await bot.api.sendMessage(callbackMessage.chat.id, text, params);
+			};
+			const inlineButtonsScope = resolveTelegramInlineButtonsScope({
+				cfg,
+				accountId
+			});
+			if (inlineButtonsScope === "off") return;
+			const chatId = callbackMessage.chat.id;
+			const isGroup = callbackMessage.chat.type === "group" || callbackMessage.chat.type === "supergroup";
+			if (inlineButtonsScope === "dm" && isGroup) return;
+			if (inlineButtonsScope === "group" && !isGroup) return;
+			const messageThreadId = callbackMessage.message_thread_id;
+			const isForum = callbackMessage.chat.is_forum === true;
+			const eventAuthContext = await resolveTelegramEventAuthorizationContext({
+				chatId,
+				isForum,
+				messageThreadId
+			});
+			const { resolvedThreadId, storeAllowFrom } = eventAuthContext;
+			const senderId = callback.from?.id ? String(callback.from.id) : "";
+			const senderUsername = callback.from?.username ?? "";
+			const authorizationMode = inlineButtonsScope === "allowlist" ? "callback-allowlist" : "callback-scope";
+			if (!authorizeTelegramEventSender({
+				chatId,
+				chatTitle: callbackMessage.chat.title,
+				isGroup,
+				senderId,
+				senderUsername,
+				mode: authorizationMode,
+				context: eventAuthContext
+			}).allowed) return;
+			const paginationMatch = data.match(/^commands_page_(\d+|noop)(?::(.+))?$/);
+			if (paginationMatch) {
+				const pageValue = paginationMatch[1];
+				if (pageValue === "noop") return;
+				const page = Number.parseInt(pageValue, 10);
+				if (Number.isNaN(page) || page < 1) return;
+				const agentId = paginationMatch[2]?.trim() || resolveDefaultAgentId(cfg) || void 0;
+				const result = buildCommandsMessagePaginated(cfg, listSkillCommandsForAgents({
+					cfg,
+					agentIds: agentId ? [agentId] : void 0
+				}), {
+					page,
+					surface: "telegram"
+				});
+				const keyboard = result.totalPages > 1 ? buildInlineKeyboard(buildCommandsPaginationKeyboard(result.currentPage, result.totalPages, agentId)) : void 0;
+				try {
+					await editCallbackMessage(result.text, keyboard ? { reply_markup: keyboard } : void 0);
+				} catch (editErr) {
+					if (!String(editErr).includes("message is not modified")) throw editErr;
+				}
+				return;
+			}
+			const modelCallback = parseModelCallbackData(data);
+			if (modelCallback) {
+				const { byProvider, providers } = await buildModelsProviderData(cfg);
+				const editMessageWithButtons = async (text, buttons) => {
+					const keyboard = buildInlineKeyboard(buttons);
+					try {
+						await editCallbackMessage(text, keyboard ? { reply_markup: keyboard } : void 0);
+					} catch (editErr) {
+						const errStr = String(editErr);
+						if (errStr.includes("no text in the message")) {
+							try {
+								await deleteCallbackMessage();
+							} catch {}
+							await replyToCallbackChat(text, keyboard ? { reply_markup: keyboard } : void 0);
+						} else if (!errStr.includes("message is not modified")) throw editErr;
+					}
+				};
+				if (modelCallback.type === "providers" || modelCallback.type === "back") {
+					if (providers.length === 0) {
+						await editMessageWithButtons("No providers available.", []);
+						return;
+					}
+					await editMessageWithButtons("Select a provider:", buildProviderKeyboard(providers.map((p) => ({
+						id: p,
+						count: byProvider.get(p)?.size ?? 0
+					}))));
+					return;
+				}
+				if (modelCallback.type === "list") {
+					const { provider, page } = modelCallback;
+					const modelSet = byProvider.get(provider);
+					if (!modelSet || modelSet.size === 0) {
+						const buttons = buildProviderKeyboard(providers.map((p) => ({
+							id: p,
+							count: byProvider.get(p)?.size ?? 0
+						})));
+						await editMessageWithButtons(`Unknown provider: ${provider}\n\nSelect a provider:`, buttons);
+						return;
+					}
+					const models = [...modelSet].toSorted();
+					const pageSize = getModelsPageSize();
+					const totalPages = calculateTotalPages(models.length, pageSize);
+					const safePage = Math.max(1, Math.min(page, totalPages));
+					const sessionState = resolveTelegramSessionState({
+						chatId,
+						isGroup,
+						isForum,
+						messageThreadId,
+						resolvedThreadId
+					});
+					const currentModel = sessionState.model;
+					const buttons = buildModelsKeyboard({
+						provider,
+						models,
+						currentModel,
+						currentPage: safePage,
+						totalPages,
+						pageSize
+					});
+					await editMessageWithButtons(formatModelsAvailableHeader({
+						provider,
+						total: models.length,
+						cfg,
+						agentDir: resolveAgentDir(cfg, sessionState.agentId),
+						sessionEntry: sessionState.sessionEntry
+					}), buttons);
+					return;
+				}
+				if (modelCallback.type === "select") {
+					const { provider, model } = modelCallback;
+					await processMessage(buildSyntheticContext(ctx, buildSyntheticTextMessage({
+						base: callbackMessage,
+						from: callback.from,
+						text: `/model ${provider}/${model}`
+					})), [], storeAllowFrom, {
+						forceWasMentioned: true,
+						messageIdOverride: callback.id
+					});
+					return;
+				}
+				return;
+			}
+			await processMessage(buildSyntheticContext(ctx, buildSyntheticTextMessage({
+				base: callbackMessage,
+				from: callback.from,
+				text: data
+			})), [], storeAllowFrom, {
+				forceWasMentioned: true,
+				messageIdOverride: callback.id
+			});
+		} catch (err) {
+			runtime.error?.(danger(`callback handler failed: ${String(err)}`));
+		}
+	});
+	bot.on("message:migrate_to_chat_id", async (ctx) => {
+		try {
+			const msg = ctx.message;
+			if (!msg?.migrate_to_chat_id) return;
+			if (shouldSkipUpdate(ctx)) return;
+			const oldChatId = String(msg.chat.id);
+			const newChatId = String(msg.migrate_to_chat_id);
+			const chatTitle = msg.chat.title ?? "Unknown";
+			runtime.log?.(warn(`[telegram] Group migrated: "${chatTitle}" ${oldChatId} → ${newChatId}`));
+			if (!resolveChannelConfigWrites({
+				cfg,
+				channelId: "telegram",
+				accountId
+			})) {
+				runtime.log?.(warn("[telegram] Config writes disabled; skipping group config migration."));
+				return;
+			}
+			const currentConfig = loadConfig();
+			const migration = migrateTelegramGroupConfig({
+				cfg: currentConfig,
+				accountId,
+				oldChatId,
+				newChatId
+			});
+			if (migration.migrated) {
+				runtime.log?.(warn(`[telegram] Migrating group config from ${oldChatId} to ${newChatId}`));
+				migrateTelegramGroupConfig({
+					cfg,
+					accountId,
+					oldChatId,
+					newChatId
+				});
+				await writeConfigFile(currentConfig);
+				runtime.log?.(warn(`[telegram] Group config migrated and saved successfully`));
+			} else if (migration.skippedExisting) runtime.log?.(warn(`[telegram] Group config already exists for ${newChatId}; leaving ${oldChatId} unchanged`));
+			else runtime.log?.(warn(`[telegram] No config found for old group ID ${oldChatId}, migration logged only`));
+		} catch (err) {
+			runtime.error?.(danger(`[telegram] Group migration handler failed: ${String(err)}`));
+		}
+	});
+	const handleInboundMessageLike = async (event) => {
+		try {
+			if (shouldSkipUpdate(event.ctxForDedupe)) return;
+			const { dmPolicy, resolvedThreadId, storeAllowFrom, groupConfig, topicConfig, effectiveGroupAllow, hasGroupAllowOverride } = await resolveTelegramEventAuthorizationContext({
+				chatId: event.chatId,
+				isForum: event.isForum,
+				messageThreadId: event.messageThreadId
+			});
+			const effectiveDmAllow = normalizeDmAllowFromWithStore({
+				allowFrom,
+				storeAllowFrom,
+				dmPolicy
+			});
+			if (event.requireConfiguredGroup && (!groupConfig || groupConfig.enabled === false)) {
+				logVerbose(`Blocked telegram channel ${event.chatId} (channel disabled)`);
+				return;
+			}
+			if (shouldSkipGroupMessage({
+				isGroup: event.isGroup,
+				chatId: event.chatId,
+				chatTitle: event.msg.chat.title,
+				resolvedThreadId,
+				senderId: event.senderId,
+				senderUsername: event.senderUsername,
+				effectiveGroupAllow,
+				hasGroupAllowOverride,
+				groupConfig,
+				topicConfig
+			})) return;
+			if (!event.isGroup && (hasInboundMedia(event.msg) || hasReplyTargetMedia(event.msg))) {
+				if (!await enforceTelegramDmAccess({
+					isGroup: event.isGroup,
+					dmPolicy,
+					msg: event.msg,
+					chatId: event.chatId,
+					effectiveDmAllow,
+					accountId,
+					bot,
+					logger
+				})) return;
+			}
+			await processInboundMessage({
+				ctx: event.ctx,
+				msg: event.msg,
+				chatId: event.chatId,
+				resolvedThreadId,
+				storeAllowFrom,
+				sendOversizeWarning: event.sendOversizeWarning,
+				oversizeLogMessage: event.oversizeLogMessage
+			});
+		} catch (err) {
+			runtime.error?.(danger(`${event.errorMessage}: ${String(err)}`));
+		}
+	};
+	bot.on("message", async (ctx) => {
+		const msg = ctx.message;
+		if (!msg) return;
+		await handleInboundMessageLike({
+			ctxForDedupe: ctx,
+			ctx: buildSyntheticContext(ctx, msg),
+			msg,
+			chatId: msg.chat.id,
+			isGroup: msg.chat.type === "group" || msg.chat.type === "supergroup",
+			isForum: msg.chat.is_forum === true,
+			messageThreadId: msg.message_thread_id,
+			senderId: msg.from?.id != null ? String(msg.from.id) : "",
+			senderUsername: msg.from?.username ?? "",
+			requireConfiguredGroup: false,
+			sendOversizeWarning: true,
+			oversizeLogMessage: "media exceeds size limit",
+			errorMessage: "handler failed"
+		});
+	});
+	bot.on("channel_post", async (ctx) => {
+		const post = ctx.channelPost;
+		if (!post) return;
+		const chatId = post.chat.id;
+		const syntheticFrom = post.sender_chat ? {
+			id: post.sender_chat.id,
+			is_bot: true,
+			first_name: post.sender_chat.title || "Channel",
+			username: post.sender_chat.username
+		} : {
+			id: chatId,
+			is_bot: true,
+			first_name: post.chat.title || "Channel",
+			username: post.chat.username
+		};
+		const syntheticMsg = {
+			...post,
+			from: post.from ?? syntheticFrom,
+			chat: {
+				...post.chat,
+				type: "supergroup"
+			}
+		};
+		await handleInboundMessageLike({
+			ctxForDedupe: ctx,
+			ctx: buildSyntheticContext(ctx, syntheticMsg),
+			msg: syntheticMsg,
+			chatId,
+			isGroup: true,
+			isForum: false,
+			senderId: post.sender_chat?.id != null ? String(post.sender_chat.id) : post.from?.id != null ? String(post.from.id) : "",
+			senderUsername: post.sender_chat?.username ?? post.from?.username ?? "",
+			requireConfiguredGroup: true,
+			sendOversizeWarning: false,
+			oversizeLogMessage: "channel post media exceeds size limit",
+			errorMessage: "channel_post handler failed"
+		});
+	});
+};
+
+//#endregion
+//#region src/telegram/group-config-helpers.ts
+function resolveTelegramGroupPromptSettings(params) {
+	const skillFilter = firstDefined(params.topicConfig?.skills, params.groupConfig?.skills);
+	const systemPromptParts = [params.groupConfig?.systemPrompt?.trim() || null, params.topicConfig?.systemPrompt?.trim() || null].filter((entry) => Boolean(entry));
+	return {
+		skillFilter,
+		groupSystemPrompt: systemPromptParts.length > 0 ? systemPromptParts.join("\n\n") : void 0
+	};
+}
+
+//#endregion
+//#region src/telegram/status-reaction-variants.ts
+const TELEGRAM_GENERIC_REACTION_FALLBACKS = [
+	"👍",
+	"👀",
+	"🔥"
+];
+const TELEGRAM_SUPPORTED_REACTION_EMOJIS = new Set([
+	"❤",
+	"👍",
+	"👎",
+	"🔥",
+	"🥰",
+	"👏",
+	"😁",
+	"🤔",
+	"🤯",
+	"😱",
+	"🤬",
+	"😢",
+	"🎉",
+	"🤩",
+	"🤮",
+	"💩",
+	"🙏",
+	"👌",
+	"🕊",
+	"🤡",
+	"🥱",
+	"🥴",
+	"😍",
+	"🐳",
+	"❤‍🔥",
+	"🌚",
+	"🌭",
+	"💯",
+	"🤣",
+	"⚡",
+	"🍌",
+	"🏆",
+	"💔",
+	"🤨",
+	"😐",
+	"🍓",
+	"🍾",
+	"💋",
+	"🖕",
+	"😈",
+	"😴",
+	"😭",
+	"🤓",
+	"👻",
+	"👨‍💻",
+	"👀",
+	"🎃",
+	"🙈",
+	"😇",
+	"😨",
+	"🤝",
+	"✍",
+	"🤗",
+	"🫡",
+	"🎅",
+	"🎄",
+	"☃",
+	"💅",
+	"🤪",
+	"🗿",
+	"🆒",
+	"💘",
+	"🙉",
+	"🦄",
+	"😘",
+	"💊",
+	"🙊",
+	"😎",
+	"👾",
+	"🤷‍♂",
+	"🤷",
+	"🤷‍♀",
+	"😡"
+]);
+const TELEGRAM_STATUS_REACTION_VARIANTS = {
+	queued: [
+		"👀",
+		"👍",
+		"🔥"
+	],
+	thinking: [
+		"🤔",
+		"🤓",
+		"👀"
+	],
+	tool: [
+		"🔥",
+		"⚡",
+		"👍"
+	],
+	coding: [
+		"👨‍💻",
+		"🔥",
+		"⚡"
+	],
+	web: [
+		"⚡",
+		"🔥",
+		"👍"
+	],
+	done: [
+		"👍",
+		"🎉",
+		"💯"
+	],
+	error: [
+		"😱",
+		"😨",
+		"🤯"
+	],
+	stallSoft: [
+		"🥱",
+		"😴",
+		"🤔"
+	],
+	stallHard: [
+		"😨",
+		"😱",
+		"⚡"
+	]
+};
+const STATUS_REACTION_EMOJI_KEYS = [
+	"queued",
+	"thinking",
+	"tool",
+	"coding",
+	"web",
+	"done",
+	"error",
+	"stallSoft",
+	"stallHard"
+];
+function normalizeEmoji(value) {
+	const trimmed = value?.trim();
+	return trimmed ? trimmed : void 0;
+}
+function toUniqueNonEmpty(values) {
+	return Array.from(new Set(values.map((value) => value.trim()).filter(Boolean)));
+}
+function resolveTelegramStatusReactionEmojis(params) {
+	const { overrides } = params;
+	const queuedFallback = normalizeEmoji(params.initialEmoji) ?? DEFAULT_EMOJIS.queued;
+	return {
+		queued: normalizeEmoji(overrides?.queued) ?? queuedFallback,
+		thinking: normalizeEmoji(overrides?.thinking) ?? DEFAULT_EMOJIS.thinking,
+		tool: normalizeEmoji(overrides?.tool) ?? DEFAULT_EMOJIS.tool,
+		coding: normalizeEmoji(overrides?.coding) ?? DEFAULT_EMOJIS.coding,
+		web: normalizeEmoji(overrides?.web) ?? DEFAULT_EMOJIS.web,
+		done: normalizeEmoji(overrides?.done) ?? DEFAULT_EMOJIS.done,
+		error: normalizeEmoji(overrides?.error) ?? DEFAULT_EMOJIS.error,
+		stallSoft: normalizeEmoji(overrides?.stallSoft) ?? DEFAULT_EMOJIS.stallSoft,
+		stallHard: normalizeEmoji(overrides?.stallHard) ?? DEFAULT_EMOJIS.stallHard
+	};
+}
+function buildTelegramStatusReactionVariants(emojis) {
+	const variantsByRequested = /* @__PURE__ */ new Map();
+	for (const key of STATUS_REACTION_EMOJI_KEYS) {
+		const requested = normalizeEmoji(emojis[key]);
+		if (!requested) continue;
+		const candidates = toUniqueNonEmpty([requested, ...TELEGRAM_STATUS_REACTION_VARIANTS[key] ?? []]);
+		variantsByRequested.set(requested, candidates);
+	}
+	return variantsByRequested;
+}
+function isTelegramSupportedReactionEmoji(emoji) {
+	return TELEGRAM_SUPPORTED_REACTION_EMOJIS.has(emoji);
+}
+function extractTelegramAllowedEmojiReactions(chat) {
+	if (!chat || typeof chat !== "object") return;
+	if (!Object.prototype.hasOwnProperty.call(chat, "available_reactions")) return;
+	const availableReactions = chat.available_reactions;
+	if (availableReactions == null) return null;
+	if (!Array.isArray(availableReactions)) return /* @__PURE__ */ new Set();
+	const allowed = /* @__PURE__ */ new Set();
+	for (const reaction of availableReactions) {
+		if (!reaction || typeof reaction !== "object") continue;
+		const typedReaction = reaction;
+		if (typedReaction.type !== "emoji" || typeof typedReaction.emoji !== "string") continue;
+		const emoji = typedReaction.emoji.trim();
+		if (emoji) allowed.add(emoji);
+	}
+	return allowed;
+}
+async function resolveTelegramAllowedEmojiReactions(params) {
+	const fromMessage = extractTelegramAllowedEmojiReactions(params.chat);
+	if (fromMessage !== void 0) return fromMessage;
+	if (params.getChat) try {
+		const fromLookup = extractTelegramAllowedEmojiReactions(await params.getChat(params.chatId));
+		if (fromLookup !== void 0) return fromLookup;
+	} catch {
+		return null;
+	}
+	return null;
+}
+function resolveTelegramReactionVariant(params) {
+	const requestedEmoji = normalizeEmoji(params.requestedEmoji);
+	if (!requestedEmoji) return;
+	const variants = toUniqueNonEmpty([...params.variantsByRequestedEmoji.get(requestedEmoji) ?? [requestedEmoji], ...TELEGRAM_GENERIC_REACTION_FALLBACKS]);
+	for (const candidate of variants) if ((params.allowedEmojiReactions == null || params.allowedEmojiReactions.has(candidate)) && isTelegramSupportedReactionEmoji(candidate)) return candidate;
+}
+
+//#endregion
+//#region src/telegram/bot-message-context.ts
+async function resolveStickerVisionSupport$1(params) {
+	try {
+		const catalog = await loadModelCatalog({ config: params.cfg });
+		const defaultModel = resolveDefaultModelForAgent({
+			cfg: params.cfg,
+			agentId: params.agentId
+		});
+		const entry = findModelInCatalog(catalog, defaultModel.provider, defaultModel.model);
+		if (!entry) return false;
+		return modelSupportsVision(entry);
+	} catch {
+		return false;
+	}
+}
+const buildTelegramMessageContext = async ({ primaryCtx, allMedia, replyMedia = [], storeAllowFrom, options, bot, cfg, account, historyLimit, groupHistories, dmPolicy, allowFrom, groupAllowFrom, ackReactionScope, logger, resolveGroupActivation, resolveGroupRequireMention, resolveTelegramGroupConfig, sendChatActionHandler }) => {
+	const msg = primaryCtx.message;
+	const chatId = msg.chat.id;
+	const isGroup = msg.chat.type === "group" || msg.chat.type === "supergroup";
+	const messageThreadId = msg.message_thread_id;
+	const isForum = msg.chat.is_forum === true;
+	const threadSpec = resolveTelegramThreadSpec({
+		isGroup,
+		isForum,
+		messageThreadId
+	});
+	const resolvedThreadId = threadSpec.scope === "forum" ? threadSpec.id : void 0;
+	const replyThreadId = threadSpec.id;
+	const { groupConfig, topicConfig } = resolveTelegramGroupConfig(chatId, resolvedThreadId);
+	const peerId = isGroup ? buildTelegramGroupPeerId(chatId, resolvedThreadId) : String(chatId);
+	const parentPeer = buildTelegramParentPeer({
+		isGroup,
+		resolvedThreadId,
+		chatId
+	});
+	const route = resolveAgentRoute({
+		cfg: loadConfig(),
+		channel: "telegram",
+		accountId: account.accountId,
+		peer: {
+			kind: isGroup ? "group" : "direct",
+			id: peerId
+		},
+		parentPeer
+	});
+	const baseSessionKey = route.sessionKey;
+	const dmThreadId = threadSpec.scope === "dm" ? threadSpec.id : void 0;
+	const sessionKey = (dmThreadId != null ? resolveThreadSessionKeys({
+		baseSessionKey,
+		threadId: String(dmThreadId)
+	}) : null)?.sessionKey ?? baseSessionKey;
+	const mentionRegexes = buildMentionRegexes(cfg, route.agentId);
+	const effectiveDmAllow = normalizeDmAllowFromWithStore({
+		allowFrom,
+		storeAllowFrom,
+		dmPolicy
+	});
+	const groupAllowOverride = firstDefined(topicConfig?.allowFrom, groupConfig?.allowFrom);
+	const effectiveGroupAllow = normalizeAllowFrom(groupAllowOverride ?? groupAllowFrom);
+	const hasGroupAllowOverride = typeof groupAllowOverride !== "undefined";
+	const senderId = msg.from?.id ? String(msg.from.id) : "";
+	const senderUsername = msg.from?.username ?? "";
+	const baseAccess = evaluateTelegramGroupBaseAccess({
+		isGroup,
+		groupConfig,
+		topicConfig,
+		hasGroupAllowOverride,
+		effectiveGroupAllow,
+		senderId,
+		senderUsername,
+		enforceAllowOverride: true,
+		requireSenderForAllowOverride: false
+	});
+	if (!baseAccess.allowed) {
+		if (baseAccess.reason === "group-disabled") {
+			logVerbose(`Blocked telegram group ${chatId} (group disabled)`);
+			return null;
+		}
+		if (baseAccess.reason === "topic-disabled") {
+			logVerbose(`Blocked telegram topic ${chatId} (${resolvedThreadId ?? "unknown"}) (topic disabled)`);
+			return null;
+		}
+		logVerbose(`Blocked telegram group sender ${senderId || "unknown"} (group allowFrom override)`);
+		return null;
+	}
+	const activationOverride = resolveGroupActivation({
+		chatId,
+		messageThreadId: resolvedThreadId,
+		sessionKey,
+		agentId: route.agentId
+	});
+	const baseRequireMention = resolveGroupRequireMention(chatId);
+	const requireMention = firstDefined(activationOverride, topicConfig?.requireMention, groupConfig?.requireMention, baseRequireMention);
+	const sendTyping = async () => {
+		await withTelegramApiErrorLogging({
+			operation: "sendChatAction",
+			fn: () => sendChatActionHandler.sendChatAction(chatId, "typing", buildTypingThreadParams(replyThreadId))
+		});
+	};
+	const sendRecordVoice = async () => {
+		try {
+			await withTelegramApiErrorLogging({
+				operation: "sendChatAction",
+				fn: () => sendChatActionHandler.sendChatAction(chatId, "record_voice", buildTypingThreadParams(replyThreadId))
+			});
+		} catch (err) {
+			logVerbose(`telegram record_voice cue failed for chat ${chatId}: ${String(err)}`);
+		}
+	};
+	if (!await enforceTelegramDmAccess({
+		isGroup,
+		dmPolicy,
+		msg,
+		chatId,
+		effectiveDmAllow,
+		accountId: account.accountId,
+		bot,
+		logger
+	})) return null;
+	recordChannelActivity({
+		channel: "telegram",
+		accountId: account.accountId,
+		direction: "inbound"
+	});
+	const botUsername = primaryCtx.me?.username?.toLowerCase();
+	const allowForCommands = isGroup ? effectiveGroupAllow : effectiveDmAllow;
+	const senderAllowedForCommands = isSenderAllowed({
+		allow: allowForCommands,
+		senderId,
+		senderUsername
+	});
+	const useAccessGroups = cfg.commands?.useAccessGroups !== false;
+	const hasControlCommandInMessage = hasControlCommand(msg.text ?? msg.caption ?? "", cfg, { botUsername });
+	const commandGate = resolveControlCommandGate({
+		useAccessGroups,
+		authorizers: [{
+			configured: allowForCommands.hasEntries,
+			allowed: senderAllowedForCommands
+		}],
+		allowTextCommands: true,
+		hasControlCommand: hasControlCommandInMessage
+	});
+	const commandAuthorized = commandGate.commandAuthorized;
+	const historyKey = isGroup ? buildTelegramGroupPeerId(chatId, resolvedThreadId) : void 0;
+	let placeholder = resolveTelegramMediaPlaceholder(msg) ?? "";
+	const cachedStickerDescription = allMedia[0]?.stickerMetadata?.cachedDescription;
+	const stickerSupportsVision = msg.sticker ? await resolveStickerVisionSupport$1({
+		cfg,
+		agentId: route.agentId
+	}) : false;
+	const stickerCacheHit = Boolean(cachedStickerDescription) && !stickerSupportsVision;
+	if (stickerCacheHit) {
+		const emoji = allMedia[0]?.stickerMetadata?.emoji;
+		const setName = allMedia[0]?.stickerMetadata?.setName;
+		const stickerContext = [emoji, setName ? `from "${setName}"` : null].filter(Boolean).join(" ");
+		placeholder = `[Sticker${stickerContext ? ` ${stickerContext}` : ""}] ${cachedStickerDescription}`;
+	}
+	const locationData = extractTelegramLocation(msg);
+	const locationText = locationData ? formatLocationText(locationData) : void 0;
+	const rawText = expandTextLinks(msg.text ?? msg.caption ?? "", msg.entities ?? msg.caption_entities).trim();
+	const hasUserText = Boolean(rawText || locationText);
+	let rawBody = [rawText, locationText].filter(Boolean).join("\n").trim();
+	if (!rawBody) rawBody = placeholder;
+	if (!rawBody && allMedia.length === 0) return null;
+	let bodyText = rawBody;
+	const hasAudio = allMedia.some((media) => media.contentType?.startsWith("audio/"));
+	let preflightTranscript;
+	if (isGroup && requireMention && hasAudio && !hasUserText && mentionRegexes.length > 0) try {
+		const { transcribeFirstAudio } = await import("./audio-preflight-CzG6BjAn.js");
+		preflightTranscript = await transcribeFirstAudio({
+			ctx: {
+				MediaPaths: allMedia.length > 0 ? allMedia.map((m) => m.path) : void 0,
+				MediaTypes: allMedia.length > 0 ? allMedia.map((m) => m.contentType).filter(Boolean) : void 0
+			},
+			cfg,
+			agentDir: void 0
+		});
+	} catch (err) {
+		logVerbose(`telegram: audio preflight transcription failed: ${String(err)}`);
+	}
+	if (hasAudio && bodyText === "<media:audio>" && preflightTranscript) bodyText = preflightTranscript;
+	if (!bodyText && allMedia.length > 0) if (hasAudio) bodyText = preflightTranscript || "<media:audio>";
+	else bodyText = `<media:image>${allMedia.length > 1 ? ` (${allMedia.length} images)` : ""}`;
+	const hasAnyMention = (msg.entities ?? msg.caption_entities ?? []).some((ent) => ent.type === "mention");
+	const explicitlyMentioned = botUsername ? hasBotMention(msg, botUsername) : false;
+	const computedWasMentioned = matchesMentionWithExplicit({
+		text: msg.text ?? msg.caption ?? "",
+		mentionRegexes,
+		explicit: {
+			hasAnyMention,
+			isExplicitlyMentioned: explicitlyMentioned,
+			canResolveExplicit: Boolean(botUsername)
+		},
+		transcript: preflightTranscript
+	});
+	const wasMentioned = options?.forceWasMentioned === true ? true : computedWasMentioned;
+	if (isGroup && commandGate.shouldBlock) {
+		logInboundDrop({
+			log: logVerbose,
+			channel: "telegram",
+			reason: "control command (unauthorized)",
+			target: senderId ?? "unknown"
+		});
+		return null;
+	}
+	const botId = primaryCtx.me?.id;
+	const replyFromId = msg.reply_to_message?.from?.id;
+	const implicitMention = botId != null && replyFromId === botId;
+	const canDetectMention = Boolean(botUsername) || mentionRegexes.length > 0;
+	const mentionGate = resolveMentionGatingWithBypass({
+		isGroup,
+		requireMention: Boolean(requireMention),
+		canDetectMention,
+		wasMentioned,
+		implicitMention: isGroup && Boolean(requireMention) && implicitMention,
+		hasAnyMention,
+		allowTextCommands: true,
+		hasControlCommand: hasControlCommandInMessage,
+		commandAuthorized
+	});
+	const effectiveWasMentioned = mentionGate.effectiveWasMentioned;
+	if (isGroup && requireMention && canDetectMention) {
+		if (mentionGate.shouldSkip) {
+			logger.info({
+				chatId,
+				reason: "no-mention"
+			}, "skipping group message");
+			recordPendingHistoryEntryIfEnabled({
+				historyMap: groupHistories,
+				historyKey: historyKey ?? "",
+				limit: historyLimit,
+				entry: historyKey ? {
+					sender: buildSenderLabel(msg, senderId || chatId),
+					body: rawBody,
+					timestamp: msg.date ? msg.date * 1e3 : void 0,
+					messageId: typeof msg.message_id === "number" ? String(msg.message_id) : void 0
+				} : null
+			});
+			return null;
+		}
+	}
+	const ackReaction = resolveAckReaction(cfg, route.agentId, {
+		channel: "telegram",
+		accountId: account.accountId
+	});
+	const removeAckAfterReply = cfg.messages?.removeAckAfterReply ?? false;
+	const shouldAckReaction$1 = () => Boolean(ackReaction && shouldAckReaction({
+		scope: ackReactionScope,
+		isDirect: !isGroup,
+		isGroup,
+		isMentionableGroup: isGroup,
+		requireMention: Boolean(requireMention),
+		canDetectMention,
+		effectiveWasMentioned,
+		shouldBypassMention: mentionGate.shouldBypassMention
+	}));
+	const api = bot.api;
+	const reactionApi = typeof api.setMessageReaction === "function" ? api.setMessageReaction.bind(api) : null;
+	const getChatApi = typeof api.getChat === "function" ? api.getChat.bind(api) : null;
+	const statusReactionsConfig = cfg.messages?.statusReactions;
+	const statusReactionsEnabled = statusReactionsConfig?.enabled === true && Boolean(reactionApi) && shouldAckReaction$1();
+	const resolvedStatusReactionEmojis = resolveTelegramStatusReactionEmojis({
+		initialEmoji: ackReaction,
+		overrides: statusReactionsConfig?.emojis
+	});
+	const statusReactionVariantsByEmoji = buildTelegramStatusReactionVariants(resolvedStatusReactionEmojis);
+	let allowedStatusReactionEmojisPromise = null;
+	const statusReactionController = statusReactionsEnabled && msg.message_id ? createStatusReactionController({
+		enabled: true,
+		adapter: { setReaction: async (emoji) => {
+			if (reactionApi) {
+				if (!allowedStatusReactionEmojisPromise) allowedStatusReactionEmojisPromise = resolveTelegramAllowedEmojiReactions({
+					chat: msg.chat,
+					chatId,
+					getChat: getChatApi ?? void 0
+				}).catch((err) => {
+					logVerbose(`telegram status-reaction available_reactions lookup failed for chat ${chatId}: ${String(err)}`);
+					return null;
+				});
+				const resolvedEmoji = resolveTelegramReactionVariant({
+					requestedEmoji: emoji,
+					variantsByRequestedEmoji: statusReactionVariantsByEmoji,
+					allowedEmojiReactions: await allowedStatusReactionEmojisPromise
+				});
+				if (!resolvedEmoji) return;
+				await reactionApi(chatId, msg.message_id, [{
+					type: "emoji",
+					emoji: resolvedEmoji
+				}]);
+			}
+		} },
+		initialEmoji: ackReaction,
+		emojis: resolvedStatusReactionEmojis,
+		timing: statusReactionsConfig?.timing,
+		onError: (err) => {
+			logVerbose(`telegram status-reaction error for chat ${chatId}: ${String(err)}`);
+		}
+	}) : null;
+	const ackReactionPromise = statusReactionController ? shouldAckReaction$1() ? Promise.resolve(statusReactionController.setQueued()).then(() => true, () => false) : null : shouldAckReaction$1() && msg.message_id && reactionApi ? withTelegramApiErrorLogging({
+		operation: "setMessageReaction",
+		fn: () => reactionApi(chatId, msg.message_id, [{
+			type: "emoji",
+			emoji: ackReaction
+		}])
+	}).then(() => true, (err) => {
+		logVerbose(`telegram react failed for chat ${chatId}: ${String(err)}`);
+		return false;
+	}) : null;
+	const replyTarget = describeReplyTarget(msg);
+	const forwardOrigin = normalizeForwardedContext(msg);
+	const replyForwardAnnotation = replyTarget?.forwardedFrom ? `[Forwarded from ${replyTarget.forwardedFrom.from}${replyTarget.forwardedFrom.date ? ` at ${(/* @__PURE__ */ new Date(replyTarget.forwardedFrom.date * 1e3)).toISOString()}` : ""}]\n` : "";
+	const replySuffix = replyTarget ? replyTarget.kind === "quote" ? `\n\n[Quoting ${replyTarget.sender}${replyTarget.id ? ` id:${replyTarget.id}` : ""}]\n${replyForwardAnnotation}"${replyTarget.body}"\n[/Quoting]` : `\n\n[Replying to ${replyTarget.sender}${replyTarget.id ? ` id:${replyTarget.id}` : ""}]\n${replyForwardAnnotation}${replyTarget.body}\n[/Replying]` : "";
+	const forwardPrefix = forwardOrigin ? `[Forwarded from ${forwardOrigin.from}${forwardOrigin.date ? ` at ${(/* @__PURE__ */ new Date(forwardOrigin.date * 1e3)).toISOString()}` : ""}]\n` : "";
+	const groupLabel = isGroup ? buildGroupLabel(msg, chatId, resolvedThreadId) : void 0;
+	const senderName = buildSenderName(msg);
+	const conversationLabel = isGroup ? groupLabel ?? `group:${chatId}` : buildSenderLabel(msg, senderId || chatId);
+	const storePath = resolveStorePath(cfg.session?.store, { agentId: route.agentId });
+	const envelopeOptions = resolveEnvelopeFormatOptions(cfg);
+	const previousTimestamp = readSessionUpdatedAt({
+		storePath,
+		sessionKey
+	});
+	const body = formatInboundEnvelope({
+		channel: "Telegram",
+		from: conversationLabel,
+		timestamp: msg.date ? msg.date * 1e3 : void 0,
+		body: `${forwardPrefix}${bodyText}${replySuffix}`,
+		chatType: isGroup ? "group" : "direct",
+		sender: {
+			name: senderName,
+			username: senderUsername || void 0,
+			id: senderId || void 0
+		},
+		previousTimestamp,
+		envelope: envelopeOptions
+	});
+	let combinedBody = body;
+	if (isGroup && historyKey && historyLimit > 0) combinedBody = buildPendingHistoryContextFromMap({
+		historyMap: groupHistories,
+		historyKey,
+		limit: historyLimit,
+		currentMessage: combinedBody,
+		formatEntry: (entry) => formatInboundEnvelope({
+			channel: "Telegram",
+			from: groupLabel ?? `group:${chatId}`,
+			timestamp: entry.timestamp,
+			body: `${entry.body} [id:${entry.messageId ?? "unknown"} chat:${chatId}]`,
+			chatType: "group",
+			senderLabel: entry.sender,
+			envelope: envelopeOptions
+		})
+	});
+	const { skillFilter, groupSystemPrompt } = resolveTelegramGroupPromptSettings({
+		groupConfig,
+		topicConfig
+	});
+	const commandBody = normalizeCommandBody(rawBody, { botUsername });
+	const inboundHistory = isGroup && historyKey && historyLimit > 0 ? (groupHistories.get(historyKey) ?? []).map((entry) => ({
+		sender: entry.sender,
+		body: entry.body,
+		timestamp: entry.timestamp
+	})) : void 0;
+	const contextMedia = [...stickerCacheHit ? [] : allMedia, ...replyMedia];
+	const ctxPayload = finalizeInboundContext({
+		Body: combinedBody,
+		BodyForAgent: bodyText,
+		InboundHistory: inboundHistory,
+		RawBody: rawBody,
+		CommandBody: commandBody,
+		From: isGroup ? buildTelegramGroupFrom(chatId, resolvedThreadId) : `telegram:${chatId}`,
+		To: `telegram:${chatId}`,
+		SessionKey: sessionKey,
+		AccountId: route.accountId,
+		ChatType: isGroup ? "group" : "direct",
+		ConversationLabel: conversationLabel,
+		GroupSubject: isGroup ? msg.chat.title ?? void 0 : void 0,
+		GroupSystemPrompt: isGroup ? groupSystemPrompt : void 0,
+		SenderName: senderName,
+		SenderId: senderId || void 0,
+		SenderUsername: senderUsername || void 0,
+		Provider: "telegram",
+		Surface: "telegram",
+		MessageSid: options?.messageIdOverride ?? String(msg.message_id),
+		ReplyToId: replyTarget?.id,
+		ReplyToBody: replyTarget?.body,
+		ReplyToSender: replyTarget?.sender,
+		ReplyToIsQuote: replyTarget?.kind === "quote" ? true : void 0,
+		ReplyToForwardedFrom: replyTarget?.forwardedFrom?.from,
+		ReplyToForwardedFromType: replyTarget?.forwardedFrom?.fromType,
+		ReplyToForwardedFromId: replyTarget?.forwardedFrom?.fromId,
+		ReplyToForwardedFromUsername: replyTarget?.forwardedFrom?.fromUsername,
+		ReplyToForwardedFromTitle: replyTarget?.forwardedFrom?.fromTitle,
+		ReplyToForwardedDate: replyTarget?.forwardedFrom?.date ? replyTarget.forwardedFrom.date * 1e3 : void 0,
+		ForwardedFrom: forwardOrigin?.from,
+		ForwardedFromType: forwardOrigin?.fromType,
+		ForwardedFromId: forwardOrigin?.fromId,
+		ForwardedFromUsername: forwardOrigin?.fromUsername,
+		ForwardedFromTitle: forwardOrigin?.fromTitle,
+		ForwardedFromSignature: forwardOrigin?.fromSignature,
+		ForwardedFromChatType: forwardOrigin?.fromChatType,
+		ForwardedFromMessageId: forwardOrigin?.fromMessageId,
+		ForwardedDate: forwardOrigin?.date ? forwardOrigin.date * 1e3 : void 0,
+		Timestamp: msg.date ? msg.date * 1e3 : void 0,
+		WasMentioned: isGroup ? effectiveWasMentioned : void 0,
+		MediaPath: contextMedia.length > 0 ? contextMedia[0]?.path : void 0,
+		MediaType: contextMedia.length > 0 ? contextMedia[0]?.contentType : void 0,
+		MediaUrl: contextMedia.length > 0 ? contextMedia[0]?.path : void 0,
+		MediaPaths: contextMedia.length > 0 ? contextMedia.map((m) => m.path) : void 0,
+		MediaUrls: contextMedia.length > 0 ? contextMedia.map((m) => m.path) : void 0,
+		MediaTypes: contextMedia.length > 0 ? contextMedia.map((m) => m.contentType).filter(Boolean) : void 0,
+		Sticker: allMedia[0]?.stickerMetadata,
+		StickerMediaIncluded: allMedia[0]?.stickerMetadata ? !stickerCacheHit : void 0,
+		...locationData ? toLocationContext(locationData) : void 0,
+		CommandAuthorized: commandAuthorized,
+		MessageThreadId: threadSpec.id,
+		IsForum: isForum,
+		OriginatingChannel: "telegram",
+		OriginatingTo: `telegram:${chatId}`
+	});
+	await recordInboundSession({
+		storePath,
+		sessionKey: ctxPayload.SessionKey ?? sessionKey,
+		ctx: ctxPayload,
+		updateLastRoute: !isGroup ? {
+			sessionKey: route.mainSessionKey,
+			channel: "telegram",
+			to: `telegram:${chatId}`,
+			accountId: route.accountId,
+			threadId: dmThreadId != null ? String(dmThreadId) : void 0
+		} : void 0,
+		onRecordError: (err) => {
+			logVerbose(`telegram: failed updating session meta: ${String(err)}`);
+		}
+	});
+	if (replyTarget && shouldLogVerbose()) {
+		const preview = replyTarget.body.replace(/\s+/g, " ").slice(0, 120);
+		logVerbose(`telegram reply-context: replyToId=${replyTarget.id} replyToSender=${replyTarget.sender} replyToBody="${preview}"`);
+	}
+	if (forwardOrigin && shouldLogVerbose()) logVerbose(`telegram forward-context: forwardedFrom="${forwardOrigin.from}" type=${forwardOrigin.fromType}`);
+	if (shouldLogVerbose()) {
+		const preview = body.slice(0, 200).replace(/\n/g, "\\n");
+		const mediaInfo = allMedia.length > 1 ? ` mediaCount=${allMedia.length}` : "";
+		const topicInfo = resolvedThreadId != null ? ` topic=${resolvedThreadId}` : "";
+		logVerbose(`telegram inbound: chatId=${chatId} from=${ctxPayload.From} len=${body.length}${mediaInfo}${topicInfo} preview="${preview}"`);
+	}
+	return {
+		ctxPayload,
+		primaryCtx,
+		msg,
+		chatId,
+		isGroup,
+		resolvedThreadId,
+		threadSpec,
+		replyThreadId,
+		isForum,
+		historyKey,
+		historyLimit,
+		groupHistories,
+		route,
+		skillFilter,
+		sendTyping,
+		sendRecordVoice,
+		ackReactionPromise,
+		reactionApi,
+		removeAckAfterReply,
+		statusReactionController,
+		accountId: account.accountId
+	};
+};
+
+//#endregion
+//#region src/telegram/draft-stream.ts
+const TELEGRAM_STREAM_MAX_CHARS = 4096;
+const DEFAULT_THROTTLE_MS = 1e3;
+function createTelegramDraftStream(params) {
+	const maxChars = Math.min(params.maxChars ?? TELEGRAM_STREAM_MAX_CHARS, TELEGRAM_STREAM_MAX_CHARS);
+	const throttleMs = Math.max(250, params.throttleMs ?? DEFAULT_THROTTLE_MS);
+	const minInitialChars = params.minInitialChars;
+	const chatId = params.chatId;
+	const threadParams = buildTelegramThreadParams(params.thread);
+	const replyParams = params.replyToMessageId != null ? {
+		...threadParams,
+		reply_to_message_id: params.replyToMessageId
+	} : threadParams;
+	const streamState = {
+		stopped: false,
+		final: false
+	};
+	let streamMessageId;
+	let lastSentText = "";
+	let lastSentParseMode;
+	let generation = 0;
+	const sendOrEditStreamMessage = async (text) => {
+		if (streamState.stopped && !streamState.final) return false;
+		const trimmed = text.trimEnd();
+		if (!trimmed) return false;
+		const rendered = params.renderText?.(trimmed) ?? { text: trimmed };
+		const renderedText = rendered.text.trimEnd();
+		const renderedParseMode = rendered.parseMode;
+		if (!renderedText) return false;
+		if (renderedText.length > maxChars) {
+			streamState.stopped = true;
+			params.warn?.(`telegram stream preview stopped (text length ${renderedText.length} > ${maxChars})`);
+			return false;
+		}
+		if (renderedText === lastSentText && renderedParseMode === lastSentParseMode) return true;
+		const sendGeneration = generation;
+		if (typeof streamMessageId !== "number" && minInitialChars != null && !streamState.final) {
+			if (renderedText.length < minInitialChars) return false;
+		}
+		lastSentText = renderedText;
+		lastSentParseMode = renderedParseMode;
+		try {
+			if (typeof streamMessageId === "number") {
+				if (renderedParseMode) await params.api.editMessageText(chatId, streamMessageId, renderedText, { parse_mode: renderedParseMode });
+				else await params.api.editMessageText(chatId, streamMessageId, renderedText);
+				return true;
+			}
+			const sendParams = renderedParseMode ? {
+				...replyParams,
+				parse_mode: renderedParseMode
+			} : replyParams;
+			const sentMessageId = (await params.api.sendMessage(chatId, renderedText, sendParams))?.message_id;
+			if (typeof sentMessageId !== "number" || !Number.isFinite(sentMessageId)) {
+				streamState.stopped = true;
+				params.warn?.("telegram stream preview stopped (missing message id from sendMessage)");
+				return false;
+			}
+			const normalizedMessageId = Math.trunc(sentMessageId);
+			if (sendGeneration !== generation) {
+				params.onSupersededPreview?.({
+					messageId: normalizedMessageId,
+					textSnapshot: renderedText,
+					parseMode: renderedParseMode
+				});
+				return true;
+			}
+			streamMessageId = normalizedMessageId;
+			return true;
+		} catch (err) {
+			streamState.stopped = true;
+			params.warn?.(`telegram stream preview failed: ${err instanceof Error ? err.message : String(err)}`);
+			return false;
+		}
+	};
+	const { loop, update, stop, clear } = createFinalizableDraftLifecycle({
+		throttleMs,
+		state: streamState,
+		sendOrEditStreamMessage,
+		readMessageId: () => streamMessageId,
+		clearMessageId: () => {
+			streamMessageId = void 0;
+		},
+		isValidMessageId: (value) => typeof value === "number" && Number.isFinite(value),
+		deleteMessage: async (messageId) => {
+			await params.api.deleteMessage(chatId, messageId);
+		},
+		onDeleteSuccess: (messageId) => {
+			params.log?.(`telegram stream preview deleted (chat=${chatId}, message=${messageId})`);
+		},
+		warn: params.warn,
+		warnPrefix: "telegram stream preview cleanup failed"
+	});
+	const forceNewMessage = () => {
+		generation += 1;
+		streamMessageId = void 0;
+		lastSentText = "";
+		lastSentParseMode = void 0;
+		loop.resetPending();
+		loop.resetThrottleWindow();
+	};
+	params.log?.(`telegram stream preview ready (maxChars=${maxChars}, throttleMs=${throttleMs})`);
+	return {
+		update,
+		flush: loop.flush,
+		messageId: () => streamMessageId,
+		clear,
+		stop,
+		forceNewMessage
+	};
+}
+
+//#endregion
+//#region src/telegram/lane-delivery.ts
+function createLaneDeliveryStateTracker() {
+	const state = {
+		delivered: false,
+		skippedNonSilent: 0,
+		failedNonSilent: 0
+	};
+	return {
+		markDelivered: () => {
+			state.delivered = true;
+		},
+		markNonSilentSkip: () => {
+			state.skippedNonSilent += 1;
+		},
+		markNonSilentFailure: () => {
+			state.failedNonSilent += 1;
+		},
+		snapshot: () => ({ ...state })
+	};
+}
+function createLaneTextDeliverer(params) {
+	const getLanePreviewText = (lane) => lane.lastPartialText;
+	const shouldSkipRegressivePreviewUpdate = (args) => {
+		const currentPreviewText = args.currentPreviewText;
+		if (currentPreviewText === void 0) return false;
+		return currentPreviewText.startsWith(args.text) && args.text.length < currentPreviewText.length && (args.skipRegressive === "always" || args.hadPreviewMessage);
+	};
+	const tryEditPreviewMessage = async (args) => {
+		try {
+			await params.editPreview({
+				laneName: args.laneName,
+				messageId: args.messageId,
+				text: args.text,
+				previewButtons: args.previewButtons,
+				context: args.context
+			});
+			if (args.updateLaneSnapshot) args.lane.lastPartialText = args.text;
+			params.markDelivered();
+			return true;
+		} catch (err) {
+			if (args.treatEditFailureAsDelivered) {
+				params.log(`telegram: ${args.laneName} preview ${args.context} edit failed after stop-created flush; treating as delivered (${String(err)})`);
+				params.markDelivered();
+				return true;
+			}
+			params.log(`telegram: ${args.laneName} preview ${args.context} edit failed; falling back to standard send (${String(err)})`);
+			return false;
+		}
+	};
+	const tryUpdatePreviewForLane = async ({ lane, laneName, text, previewButtons, stopBeforeEdit = false, updateLaneSnapshot = false, skipRegressive, context, previewMessageId: previewMessageIdOverride, previewTextSnapshot }) => {
+		if (!lane.stream) return false;
+		const lanePreviewMessageId = lane.stream.messageId();
+		const hadPreviewMessage = typeof previewMessageIdOverride === "number" || typeof lanePreviewMessageId === "number";
+		if (stopBeforeEdit && !hadPreviewMessage && context === "final") {
+			lane.stream.update(text);
+			await params.stopDraftLane(lane);
+			const previewMessageId = lane.stream.messageId();
+			if (typeof previewMessageId !== "number") return false;
+			if (shouldSkipRegressivePreviewUpdate({
+				currentPreviewText: previewTextSnapshot ?? getLanePreviewText(lane),
+				text,
+				skipRegressive,
+				hadPreviewMessage
+			})) {
+				params.markDelivered();
+				return true;
+			}
+			return tryEditPreviewMessage({
+				laneName,
+				messageId: previewMessageId,
+				text,
+				context,
+				previewButtons,
+				updateLaneSnapshot,
+				lane,
+				treatEditFailureAsDelivered: true
+			});
+		}
+		if (stopBeforeEdit) await params.stopDraftLane(lane);
+		const previewMessageId = typeof previewMessageIdOverride === "number" ? previewMessageIdOverride : lane.stream.messageId();
+		if (typeof previewMessageId !== "number") return false;
+		if (shouldSkipRegressivePreviewUpdate({
+			currentPreviewText: previewTextSnapshot ?? getLanePreviewText(lane),
+			text,
+			skipRegressive,
+			hadPreviewMessage
+		})) {
+			params.markDelivered();
+			return true;
+		}
+		return tryEditPreviewMessage({
+			laneName,
+			messageId: previewMessageId,
+			text,
+			context,
+			previewButtons,
+			updateLaneSnapshot,
+			lane,
+			treatEditFailureAsDelivered: false
+		});
+	};
+	const consumeArchivedAnswerPreviewForFinal = async ({ lane, text, payload, previewButtons, canEditViaPreview }) => {
+		const archivedPreview = params.archivedAnswerPreviews.shift();
+		if (!archivedPreview) return;
+		if (canEditViaPreview) {
+			if (await tryUpdatePreviewForLane({
+				lane,
+				laneName: "answer",
+				text,
+				previewButtons,
+				stopBeforeEdit: false,
+				skipRegressive: "existingOnly",
+				context: "final",
+				previewMessageId: archivedPreview.messageId,
+				previewTextSnapshot: archivedPreview.textSnapshot
+			})) return "preview-finalized";
+		}
+		try {
+			await params.deletePreviewMessage(archivedPreview.messageId);
+		} catch (err) {
+			params.log(`telegram: archived answer preview cleanup failed (${archivedPreview.messageId}): ${String(err)}`);
+		}
+		return await params.sendPayload(params.applyTextToPayload(payload, text)) ? "sent" : "skipped";
+	};
+	return async ({ laneName, text, payload, infoKind, previewButtons, allowPreviewUpdateForNonFinal = false }) => {
+		const lane = params.lanes[laneName];
+		const hasMedia = Boolean(payload.mediaUrl) || (payload.mediaUrls?.length ?? 0) > 0;
+		const canEditViaPreview = !hasMedia && text.length > 0 && text.length <= params.draftMaxChars && !payload.isError;
+		if (infoKind === "final") {
+			if (laneName === "answer") {
+				const archivedResult = await consumeArchivedAnswerPreviewForFinal({
+					lane,
+					text,
+					payload,
+					previewButtons,
+					canEditViaPreview
+				});
+				if (archivedResult) return archivedResult;
+			}
+			if (canEditViaPreview && !params.finalizedPreviewByLane[laneName]) {
+				await params.flushDraftLane(lane);
+				if (laneName === "answer") {
+					const archivedResultAfterFlush = await consumeArchivedAnswerPreviewForFinal({
+						lane,
+						text,
+						payload,
+						previewButtons,
+						canEditViaPreview
+					});
+					if (archivedResultAfterFlush) return archivedResultAfterFlush;
+				}
+				if (await tryUpdatePreviewForLane({
+					lane,
+					laneName,
+					text,
+					previewButtons,
+					stopBeforeEdit: true,
+					skipRegressive: "existingOnly",
+					context: "final"
+				})) {
+					params.finalizedPreviewByLane[laneName] = true;
+					return "preview-finalized";
+				}
+			} else if (!hasMedia && !payload.isError && text.length > params.draftMaxChars) params.log(`telegram: preview final too long for edit (${text.length} > ${params.draftMaxChars}); falling back to standard send`);
+			await params.stopDraftLane(lane);
+			return await params.sendPayload(params.applyTextToPayload(payload, text)) ? "sent" : "skipped";
+		}
+		if (allowPreviewUpdateForNonFinal && canEditViaPreview) {
+			if (await tryUpdatePreviewForLane({
+				lane,
+				laneName,
+				text,
+				previewButtons,
+				stopBeforeEdit: false,
+				updateLaneSnapshot: true,
+				skipRegressive: "always",
+				context: "update"
+			})) return "preview-updated";
+		}
+		return await params.sendPayload(params.applyTextToPayload(payload, text)) ? "sent" : "skipped";
+	};
+}
+
+//#endregion
+//#region src/telegram/reasoning-lane-coordinator.ts
+const REASONING_MESSAGE_PREFIX = "Reasoning:\n";
+const REASONING_TAG_PREFIXES = [
+	"<think",
+	"<thinking",
+	"<thought",
+	"<antthinking",
+	"</think",
+	"</thinking",
+	"</thought",
+	"</antthinking"
+];
+const THINKING_TAG_RE = /<\s*(\/?)\s*(?:think(?:ing)?|thought|antthinking)\b[^<>]*>/gi;
+function extractThinkingFromTaggedStreamOutsideCode(text) {
+	if (!text) return "";
+	const codeRegions = findCodeRegions(text);
+	let result = "";
+	let lastIndex = 0;
+	let inThinking = false;
+	THINKING_TAG_RE.lastIndex = 0;
+	for (const match of text.matchAll(THINKING_TAG_RE)) {
+		const idx = match.index ?? 0;
+		if (isInsideCode(idx, codeRegions)) continue;
+		if (inThinking) result += text.slice(lastIndex, idx);
+		inThinking = !(match[1] === "/");
+		lastIndex = idx + match[0].length;
+	}
+	if (inThinking) result += text.slice(lastIndex);
+	return result.trim();
+}
+function isPartialReasoningTagPrefix(text) {
+	const trimmed = text.trimStart().toLowerCase();
+	if (!trimmed.startsWith("<")) return false;
+	if (trimmed.includes(">")) return false;
+	return REASONING_TAG_PREFIXES.some((prefix) => prefix.startsWith(trimmed));
+}
+function splitTelegramReasoningText(text) {
+	if (typeof text !== "string") return {};
+	const trimmed = text.trim();
+	if (isPartialReasoningTagPrefix(trimmed)) return {};
+	if (trimmed.startsWith(REASONING_MESSAGE_PREFIX) && trimmed.length > 11) return { reasoningText: trimmed };
+	const taggedReasoning = extractThinkingFromTaggedStreamOutsideCode(text);
+	const strippedAnswer = stripReasoningTagsFromText(text, {
+		mode: "strict",
+		trim: "both"
+	});
+	if (!taggedReasoning && strippedAnswer === text) return { answerText: text };
+	return {
+		reasoningText: taggedReasoning ? formatReasoningMessage(taggedReasoning) : void 0,
+		answerText: strippedAnswer || void 0
+	};
+}
+function createTelegramReasoningStepState() {
+	let reasoningStatus = "none";
+	let bufferedFinalAnswer;
+	const noteReasoningHint = () => {
+		if (reasoningStatus === "none") reasoningStatus = "hinted";
+	};
+	const noteReasoningDelivered = () => {
+		reasoningStatus = "delivered";
+	};
+	const shouldBufferFinalAnswer = () => {
+		return reasoningStatus === "hinted" && !bufferedFinalAnswer;
+	};
+	const bufferFinalAnswer = (value) => {
+		bufferedFinalAnswer = value;
+	};
+	const takeBufferedFinalAnswer = () => {
+		const value = bufferedFinalAnswer;
+		bufferedFinalAnswer = void 0;
+		return value;
+	};
+	const resetForNextStep = () => {
+		reasoningStatus = "none";
+		bufferedFinalAnswer = void 0;
+	};
+	return {
+		noteReasoningHint,
+		noteReasoningDelivered,
+		shouldBufferFinalAnswer,
+		bufferFinalAnswer,
+		takeBufferedFinalAnswer,
+		resetForNextStep
+	};
+}
+
+//#endregion
+//#region src/telegram/bot-message-dispatch.ts
+const EMPTY_RESPONSE_FALLBACK$1 = "No response generated. Please try again.";
+/** Minimum chars before sending first streaming message (improves push notification UX) */
+const DRAFT_MIN_INITIAL_CHARS = 30;
+const PROGRESS_DRAFT_LABEL = "Working";
+function formatTelegramProgressToolName(name) {
+	const normalized = name?.trim();
+	if (!normalized) return "Tool";
+	return normalized.replace(/[_-]+/g, " ").split(/\s+/).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ");
+}
+function formatTelegramToolProgressDraft(payload) {
+	return `${PROGRESS_DRAFT_LABEL}\n\`🛠️ ${formatTelegramProgressToolName(payload.name)}\``;
+}
+async function resolveStickerVisionSupport(cfg, agentId) {
+	try {
+		const catalog = await loadModelCatalog({ config: cfg });
+		const defaultModel = resolveDefaultModelForAgent({
+			cfg,
+			agentId
+		});
+		const entry = findModelInCatalog(catalog, defaultModel.provider, defaultModel.model);
+		if (!entry) return false;
+		return modelSupportsVision(entry);
+	} catch {
+		return false;
+	}
+}
+function pruneStickerMediaFromContext(ctxPayload, opts) {
+	if (opts?.stickerMediaIncluded === false) return;
+	const nextMediaPaths = Array.isArray(ctxPayload.MediaPaths) ? ctxPayload.MediaPaths.slice(1) : void 0;
+	const nextMediaUrls = Array.isArray(ctxPayload.MediaUrls) ? ctxPayload.MediaUrls.slice(1) : void 0;
+	const nextMediaTypes = Array.isArray(ctxPayload.MediaTypes) ? ctxPayload.MediaTypes.slice(1) : void 0;
+	ctxPayload.MediaPaths = nextMediaPaths && nextMediaPaths.length > 0 ? nextMediaPaths : void 0;
+	ctxPayload.MediaUrls = nextMediaUrls && nextMediaUrls.length > 0 ? nextMediaUrls : void 0;
+	ctxPayload.MediaTypes = nextMediaTypes && nextMediaTypes.length > 0 ? nextMediaTypes : void 0;
+	ctxPayload.MediaPath = ctxPayload.MediaPaths?.[0];
+	ctxPayload.MediaUrl = ctxPayload.MediaUrls?.[0] ?? ctxPayload.MediaPath;
+	ctxPayload.MediaType = ctxPayload.MediaTypes?.[0];
+}
+function resolveTelegramReasoningLevel(params) {
+	const { cfg, sessionKey, agentId } = params;
+	if (!sessionKey) return "off";
+	try {
+		const store = loadSessionStore(resolveStorePath(cfg.session?.store, { agentId }), { skipCache: true });
+		const level = (store[sessionKey.toLowerCase()] ?? store[sessionKey])?.reasoningLevel;
+		if (level === "on" || level === "stream") return level;
+	} catch {}
+	return "off";
+}
+const dispatchTelegramMessage = async ({ context, bot, cfg, runtime, replyToMode, streamMode, textLimit, telegramCfg, opts }) => {
+	const { ctxPayload, msg, chatId, isGroup, threadSpec, historyKey, historyLimit, groupHistories, route, skillFilter, sendTyping, sendRecordVoice, ackReactionPromise, reactionApi, removeAckAfterReply, statusReactionController } = context;
+	const draftMaxChars = Math.min(textLimit, 4096);
+	const tableMode = resolveMarkdownTableMode({
+		cfg,
+		channel: "telegram",
+		accountId: route.accountId
+	});
+	const renderDraftPreview = (text) => ({
+		text: renderTelegramHtmlText(text, { tableMode }),
+		parseMode: "HTML"
+	});
+	const accountBlockStreamingEnabled = typeof telegramCfg.blockStreaming === "boolean" ? telegramCfg.blockStreaming : cfg.agents?.defaults?.blockStreamingDefault === "on";
+	const resolvedReasoningLevel = resolveTelegramReasoningLevel({
+		cfg,
+		sessionKey: ctxPayload.SessionKey,
+		agentId: route.agentId
+	});
+	const forceBlockStreamingForReasoning = resolvedReasoningLevel === "on";
+	const streamReasoningDraft = resolvedReasoningLevel === "stream";
+	const previewStreamingEnabled = streamMode !== "off";
+	const canStreamAnswerDraft = previewStreamingEnabled && !accountBlockStreamingEnabled && !forceBlockStreamingForReasoning;
+	const canStreamReasoningDraft = canStreamAnswerDraft || streamReasoningDraft;
+	const draftReplyToMessageId = replyToMode !== "off" && typeof msg.message_id === "number" ? msg.message_id : void 0;
+	const draftMinInitialChars = DRAFT_MIN_INITIAL_CHARS;
+	const mediaLocalRoots = getAgentScopedMediaLocalRoots(cfg, route.agentId);
+	const archivedAnswerPreviews = [];
+	const archivedReasoningPreviewIds = [];
+	const createDraftLane = (laneName, enabled) => {
+		return {
+			stream: enabled ? createTelegramDraftStream({
+				api: bot.api,
+				chatId,
+				maxChars: draftMaxChars,
+				thread: threadSpec,
+				replyToMessageId: draftReplyToMessageId,
+				minInitialChars: draftMinInitialChars,
+				renderText: renderDraftPreview,
+				onSupersededPreview: laneName === "answer" || laneName === "reasoning" ? (preview) => {
+					if (laneName === "reasoning") {
+						if (!archivedReasoningPreviewIds.includes(preview.messageId)) archivedReasoningPreviewIds.push(preview.messageId);
+						return;
+					}
+					archivedAnswerPreviews.push({
+						messageId: preview.messageId,
+						textSnapshot: preview.textSnapshot
+					});
+				} : void 0,
+				log: logVerbose,
+				warn: logVerbose
+			}) : void 0,
+			lastPartialText: "",
+			hasStreamedMessage: false
+		};
+	};
+	const lanes = {
+		answer: createDraftLane("answer", canStreamAnswerDraft),
+		reasoning: createDraftLane("reasoning", canStreamReasoningDraft)
+	};
+	const answerLane = lanes.answer;
+	const reasoningLane = lanes.reasoning;
+	const progressDraftsEnabled = telegramCfg.streaming === "progress" && Boolean(answerLane.stream);
+	let splitReasoningOnNextStream = false;
+	const reasoningStepState = createTelegramReasoningStepState();
+	const splitTextIntoLaneSegments = (text) => {
+		const split = splitTelegramReasoningText(text);
+		const segments = [];
+		const suppressReasoning = resolvedReasoningLevel === "off";
+		if (split.reasoningText && !suppressReasoning) segments.push({
+			lane: "reasoning",
+			text: split.reasoningText
+		});
+		if (split.answerText) segments.push({
+			lane: "answer",
+			text: split.answerText
+		});
+		return {
+			segments,
+			suppressedReasoningOnly: Boolean(split.reasoningText) && suppressReasoning && !split.answerText
+		};
+	};
+	const resetDraftLaneState = (lane) => {
+		lane.lastPartialText = "";
+		lane.hasStreamedMessage = false;
+	};
+	const updateDraftFromPartial = (lane, text) => {
+		const laneStream = lane.stream;
+		if (!laneStream || !text) return;
+		if (text === lane.lastPartialText) return;
+		lane.hasStreamedMessage = true;
+		if (lane.lastPartialText && lane.lastPartialText.startsWith(text) && text.length < lane.lastPartialText.length) return;
+		lane.lastPartialText = text;
+		laneStream.update(text);
+	};
+	const pushToolProgressDraft = async (payload) => {
+		if (!progressDraftsEnabled || !answerLane.stream) return;
+		const text = formatTelegramToolProgressDraft(payload);
+		answerLane.stream.update(text);
+		answerLane.lastPartialText = text;
+		answerLane.hasStreamedMessage = true;
+		await answerLane.stream.flush();
+	};
+	const ingestDraftLaneSegments = (text) => {
+		const split = splitTextIntoLaneSegments(text);
+		for (const segment of split.segments) {
+			if (segment.lane === "reasoning") {
+				reasoningStepState.noteReasoningHint();
+				reasoningStepState.noteReasoningDelivered();
+			}
+			updateDraftFromPartial(lanes[segment.lane], segment.text);
+		}
+	};
+	const flushDraftLane = async (lane) => {
+		if (!lane.stream) return;
+		await lane.stream.flush();
+	};
+	const disableBlockStreaming = !previewStreamingEnabled ? true : forceBlockStreamingForReasoning ? false : typeof telegramCfg.blockStreaming === "boolean" ? !telegramCfg.blockStreaming : canStreamAnswerDraft ? true : void 0;
+	const { onModelSelected, ...prefixOptions } = createReplyPrefixOptions({
+		cfg,
+		agentId: route.agentId,
+		channel: "telegram",
+		accountId: route.accountId
+	});
+	const chunkMode = resolveChunkMode(cfg, "telegram", route.accountId);
+	const sticker = ctxPayload.Sticker;
+	if (sticker?.fileId && sticker.fileUniqueId && ctxPayload.MediaPath) {
+		const agentDir = resolveAgentDir(cfg, route.agentId);
+		const stickerSupportsVision = await resolveStickerVisionSupport(cfg, route.agentId);
+		let description = sticker.cachedDescription ?? null;
+		if (!description) description = await describeStickerImage({
+			imagePath: ctxPayload.MediaPath,
+			cfg,
+			agentDir,
+			agentId: route.agentId
+		});
+		if (description) {
+			const stickerContext = [sticker.emoji, sticker.setName ? `from "${sticker.setName}"` : null].filter(Boolean).join(" ");
+			const formattedDesc = `[Sticker${stickerContext ? ` ${stickerContext}` : ""}] ${description}`;
+			sticker.cachedDescription = description;
+			if (!stickerSupportsVision) {
+				ctxPayload.Body = formattedDesc;
+				ctxPayload.BodyForAgent = formattedDesc;
+				pruneStickerMediaFromContext(ctxPayload, { stickerMediaIncluded: ctxPayload.StickerMediaIncluded });
+			}
+			if (sticker.fileId) {
+				cacheSticker({
+					fileId: sticker.fileId,
+					fileUniqueId: sticker.fileUniqueId,
+					emoji: sticker.emoji,
+					setName: sticker.setName,
+					description,
+					cachedAt: (/* @__PURE__ */ new Date()).toISOString(),
+					receivedFrom: ctxPayload.From
+				});
+				logVerbose(`telegram: cached sticker description for ${sticker.fileUniqueId}`);
+			} else logVerbose(`telegram: skipped sticker cache (missing fileId)`);
+		}
+	}
+	const replyQuoteText = ctxPayload.ReplyToIsQuote && ctxPayload.ReplyToBody ? ctxPayload.ReplyToBody.trim() || void 0 : void 0;
+	const deliveryState = createLaneDeliveryStateTracker();
+	const finalizedPreviewByLane = {
+		answer: false,
+		reasoning: false
+	};
+	const clearGroupHistory = () => {
+		if (isGroup && historyKey) clearHistoryEntriesIfEnabled({
+			historyMap: groupHistories,
+			historyKey,
+			limit: historyLimit
+		});
+	};
+	const deliveryBaseOptions = {
+		chatId: String(chatId),
+		token: opts.token,
+		runtime,
+		bot,
+		mediaLocalRoots,
+		replyToMode,
+		textLimit,
+		thread: threadSpec,
+		tableMode,
+		chunkMode,
+		linkPreview: telegramCfg.linkPreview,
+		replyQuoteText
+	};
+	const applyTextToPayload = (payload, text) => {
+		if (payload.text === text) return payload;
+		return {
+			...payload,
+			text
+		};
+	};
+	const sendPayload = async (payload) => {
+		const result = await deliverReplies({
+			...deliveryBaseOptions,
+			replies: [payload],
+			onVoiceRecording: sendRecordVoice
+		});
+		if (result.delivered) deliveryState.markDelivered();
+		return result.delivered;
+	};
+	const deliverLaneText = createLaneTextDeliverer({
+		lanes,
+		archivedAnswerPreviews,
+		finalizedPreviewByLane,
+		draftMaxChars,
+		applyTextToPayload,
+		sendPayload,
+		flushDraftLane,
+		stopDraftLane: async (lane) => {
+			await lane.stream?.stop();
+		},
+		editPreview: async ({ messageId, text, previewButtons }) => {
+			await editMessageTelegram(chatId, messageId, text, {
+				api: bot.api,
+				cfg,
+				accountId: route.accountId,
+				linkPreview: telegramCfg.linkPreview,
+				buttons: previewButtons
+			});
+		},
+		deletePreviewMessage: async (messageId) => {
+			await bot.api.deleteMessage(chatId, messageId);
+		},
+		log: logVerbose,
+		markDelivered: () => {
+			deliveryState.markDelivered();
+		}
+	});
+	let queuedFinal = false;
+	if (statusReactionController) statusReactionController.setThinking();
+	const typingCallbacks = createTypingCallbacks({
+		start: sendTyping,
+		onStartError: (err) => {
+			logTypingFailure({
+				log: logVerbose,
+				channel: "telegram",
+				target: String(chatId),
+				error: err
+			});
+		}
+	});
+	try {
+		({queuedFinal} = await dispatchReplyWithBufferedBlockDispatcher({
+			ctx: ctxPayload,
+			cfg,
+			dispatcherOptions: {
+				...prefixOptions,
+				typingCallbacks,
+				deliver: async (payload, info) => {
+					const previewButtons = (payload.channelData?.telegram)?.buttons;
+					const split = splitTextIntoLaneSegments(payload.text);
+					const segments = split.segments;
+					const hasMedia = Boolean(payload.mediaUrl) || (payload.mediaUrls?.length ?? 0) > 0;
+					const flushBufferedFinalAnswer = async () => {
+						const buffered = reasoningStepState.takeBufferedFinalAnswer();
+						if (!buffered) return;
+						const bufferedButtons = (buffered.payload.channelData?.telegram)?.buttons;
+						await deliverLaneText({
+							laneName: "answer",
+							text: buffered.text,
+							payload: buffered.payload,
+							infoKind: "final",
+							previewButtons: bufferedButtons
+						});
+						reasoningStepState.resetForNextStep();
+					};
+					for (const segment of segments) {
+						if (segment.lane === "answer" && info.kind === "final" && reasoningStepState.shouldBufferFinalAnswer()) {
+							reasoningStepState.bufferFinalAnswer({
+								payload,
+								text: segment.text
+							});
+							continue;
+						}
+						if (segment.lane === "reasoning") reasoningStepState.noteReasoningHint();
+						const result = await deliverLaneText({
+							laneName: segment.lane,
+							text: segment.text,
+							payload,
+							infoKind: info.kind,
+							previewButtons,
+							allowPreviewUpdateForNonFinal: segment.lane === "reasoning"
+						});
+						if (segment.lane === "reasoning") {
+							if (result !== "skipped") {
+								reasoningStepState.noteReasoningDelivered();
+								await flushBufferedFinalAnswer();
+							}
+							continue;
+						}
+						if (info.kind === "final") {
+							if (reasoningLane.hasStreamedMessage) finalizedPreviewByLane.reasoning = true;
+							reasoningStepState.resetForNextStep();
+						}
+					}
+					if (segments.length > 0) return;
+					if (split.suppressedReasoningOnly) {
+						if (hasMedia) await sendPayload(typeof payload.text === "string" ? {
+							...payload,
+							text: ""
+						} : payload);
+						if (info.kind === "final") await flushBufferedFinalAnswer();
+						return;
+					}
+					if (info.kind === "final") {
+						await answerLane.stream?.stop();
+						await reasoningLane.stream?.stop();
+						reasoningStepState.resetForNextStep();
+					}
+					if (!(hasMedia || typeof payload.text !== "string" || payload.text.length > 0)) {
+						if (info.kind === "final") await flushBufferedFinalAnswer();
+						return;
+					}
+					await sendPayload(payload);
+					if (info.kind === "final") await flushBufferedFinalAnswer();
+				},
+				onSkip: (_payload, info) => {
+					if (info.reason !== "silent") deliveryState.markNonSilentSkip();
+				},
+				onError: (err, info) => {
+					deliveryState.markNonSilentFailure();
+					runtime.error?.(danger(`telegram ${info.kind} reply failed: ${String(err)}`));
+				}
+			},
+			replyOptions: {
+				skillFilter,
+				disableBlockStreaming,
+				allowProgressCallbacksWhenSourceDeliverySuppressed: progressDraftsEnabled ? true : void 0,
+				onPartialReply: answerLane.stream || reasoningLane.stream ? (payload) => ingestDraftLaneSegments(payload.text) : void 0,
+				onReasoningStream: reasoningLane.stream ? (payload) => {
+					if (splitReasoningOnNextStream) {
+						reasoningLane.stream?.forceNewMessage();
+						resetDraftLaneState(reasoningLane);
+						splitReasoningOnNextStream = false;
+					}
+					ingestDraftLaneSegments(payload.text);
+				} : void 0,
+				onAssistantMessageStart: answerLane.stream ? async () => {
+					reasoningStepState.resetForNextStep();
+					if (answerLane.hasStreamedMessage) {
+						const previewMessageId = answerLane.stream?.messageId();
+						if (typeof previewMessageId === "number" && !finalizedPreviewByLane.answer) archivedAnswerPreviews.push({
+							messageId: previewMessageId,
+							textSnapshot: answerLane.lastPartialText
+						});
+						answerLane.stream?.forceNewMessage();
+					}
+					resetDraftLaneState(answerLane);
+					finalizedPreviewByLane.answer = false;
+				} : void 0,
+				onReasoningEnd: reasoningLane.stream ? () => {
+					splitReasoningOnNextStream = reasoningLane.hasStreamedMessage;
+				} : void 0,
+				onToolStart: progressDraftsEnabled || statusReactionController ? async (payload) => {
+					const progressPromise = pushToolProgressDraft(payload);
+					if (statusReactionController) await statusReactionController.setTool(payload.name);
+					await progressPromise;
+				} : void 0,
+				onModelSelected
+			}
+		}));
+	} finally {
+		const streamCleanupStates = /* @__PURE__ */ new Map();
+		const lanesToCleanup = [{
+			laneName: "answer",
+			lane: answerLane
+		}, {
+			laneName: "reasoning",
+			lane: reasoningLane
+		}];
+		for (const laneState of lanesToCleanup) {
+			const stream = laneState.lane.stream;
+			if (!stream) continue;
+			const shouldClear = !finalizedPreviewByLane[laneState.laneName];
+			const existing = streamCleanupStates.get(stream);
+			if (!existing) {
+				streamCleanupStates.set(stream, { shouldClear });
+				continue;
+			}
+			existing.shouldClear = existing.shouldClear && shouldClear;
+		}
+		for (const [stream, cleanupState] of streamCleanupStates) {
+			await stream.stop();
+			if (cleanupState.shouldClear) await stream.clear();
+		}
+		for (const archivedPreview of archivedAnswerPreviews) try {
+			await bot.api.deleteMessage(chatId, archivedPreview.messageId);
+		} catch (err) {
+			logVerbose(`telegram: archived answer preview cleanup failed (${archivedPreview.messageId}): ${String(err)}`);
+		}
+		for (const messageId of archivedReasoningPreviewIds) try {
+			await bot.api.deleteMessage(chatId, messageId);
+		} catch (err) {
+			logVerbose(`telegram: archived reasoning preview cleanup failed (${messageId}): ${String(err)}`);
+		}
+	}
+	let sentFallback = false;
+	const deliverySummary = deliveryState.snapshot();
+	if (!deliverySummary.delivered && (deliverySummary.skippedNonSilent > 0 || deliverySummary.failedNonSilent > 0)) sentFallback = (await deliverReplies({
+		replies: [{ text: EMPTY_RESPONSE_FALLBACK$1 }],
+		...deliveryBaseOptions
+	})).delivered;
+	const hasFinalResponse = queuedFinal || sentFallback;
+	if (statusReactionController && !hasFinalResponse) statusReactionController.setError().catch((err) => {
+		logVerbose(`telegram: status reaction error finalize failed: ${String(err)}`);
+	});
+	if (!hasFinalResponse) {
+		clearGroupHistory();
+		return;
+	}
+	if (statusReactionController) statusReactionController.setDone().catch((err) => {
+		logVerbose(`telegram: status reaction finalize failed: ${String(err)}`);
+	});
+	else removeAckReactionAfterReply({
+		removeAfterReply: removeAckAfterReply,
+		ackReactionPromise,
+		ackReactionValue: ackReactionPromise ? "ack" : null,
+		remove: () => reactionApi?.(chatId, msg.message_id ?? 0, []) ?? Promise.resolve(),
+		onError: (err) => {
+			if (!msg.message_id) return;
+			logAckFailure({
+				log: logVerbose,
+				channel: "telegram",
+				target: `${chatId}/${msg.message_id}`,
+				error: err
+			});
+		}
+	});
+	clearGroupHistory();
+};
+
+//#endregion
+//#region src/telegram/bot-message.ts
+const createTelegramMessageProcessor = (deps) => {
+	const { bot, cfg, account, telegramCfg, historyLimit, groupHistories, dmPolicy, allowFrom, groupAllowFrom, ackReactionScope, logger, resolveGroupActivation, resolveGroupRequireMention, resolveTelegramGroupConfig, sendChatActionHandler, runtime, replyToMode, streamMode, textLimit, opts } = deps;
+	return async (primaryCtx, allMedia, storeAllowFrom, options, replyMedia) => {
+		const context = await buildTelegramMessageContext({
+			primaryCtx,
+			allMedia,
+			replyMedia,
+			storeAllowFrom,
+			options,
+			bot,
+			cfg,
+			account,
+			historyLimit,
+			groupHistories,
+			dmPolicy,
+			allowFrom,
+			groupAllowFrom,
+			ackReactionScope,
+			logger,
+			resolveGroupActivation,
+			resolveGroupRequireMention,
+			resolveTelegramGroupConfig,
+			sendChatActionHandler
+		});
+		if (!context) return;
+		await dispatchTelegramMessage({
+			context,
+			bot,
+			cfg,
+			runtime,
+			replyToMode,
+			streamMode,
+			textLimit,
+			telegramCfg,
+			opts
+		});
+	};
+};
+
+//#endregion
+//#region src/telegram/bot-native-command-menu.ts
+const TELEGRAM_MAX_COMMANDS = 100;
+const TELEGRAM_COMMAND_RETRY_RATIO = .8;
+function isBotCommandsTooMuchError(err) {
+	if (!err) return false;
+	const pattern = /\bBOT_COMMANDS_TOO_MUCH\b/i;
+	if (typeof err === "string") return pattern.test(err);
+	if (err instanceof Error) {
+		if (pattern.test(err.message)) return true;
+	}
+	if (typeof err === "object") {
+		const maybe = err;
+		if (typeof maybe.description === "string" && pattern.test(maybe.description)) return true;
+		if (typeof maybe.message === "string" && pattern.test(maybe.message)) return true;
+	}
+	return false;
+}
+function buildPluginTelegramMenuCommands(params) {
+	const { specs, existingCommands } = params;
+	const commands = [];
+	const issues = [];
+	const pluginCommandNames = /* @__PURE__ */ new Set();
+	for (const spec of specs) {
+		const normalized = normalizeTelegramCommandName(spec.name);
+		if (!normalized || !TELEGRAM_COMMAND_NAME_PATTERN.test(normalized)) {
+			issues.push(`Plugin command "/${spec.name}" is invalid for Telegram (use a-z, 0-9, underscore; max 32 chars).`);
+			continue;
+		}
+		const description = spec.description.trim();
+		if (!description) {
+			issues.push(`Plugin command "/${normalized}" is missing a description.`);
+			continue;
+		}
+		if (existingCommands.has(normalized)) {
+			if (pluginCommandNames.has(normalized)) issues.push(`Plugin command "/${normalized}" is duplicated.`);
+			else issues.push(`Plugin command "/${normalized}" conflicts with an existing Telegram command.`);
+			continue;
+		}
+		pluginCommandNames.add(normalized);
+		existingCommands.add(normalized);
+		commands.push({
+			command: normalized,
+			description
+		});
+	}
+	return {
+		commands,
+		issues
+	};
+}
+function buildCappedTelegramMenuCommands(params) {
+	const { allCommands } = params;
+	const maxCommands = params.maxCommands ?? TELEGRAM_MAX_COMMANDS;
+	const totalCommands = allCommands.length;
+	const overflowCount = Math.max(0, totalCommands - maxCommands);
+	return {
+		commandsToRegister: allCommands.slice(0, maxCommands),
+		totalCommands,
+		maxCommands,
+		overflowCount
+	};
+}
+function syncTelegramMenuCommands(params) {
+	const { bot, runtime, commandsToRegister } = params;
+	const sync = async () => {
+		if (typeof bot.api.deleteMyCommands === "function") await withTelegramApiErrorLogging({
+			operation: "deleteMyCommands",
+			runtime,
+			fn: () => bot.api.deleteMyCommands()
+		}).catch(() => {});
+		if (commandsToRegister.length === 0) return;
+		let retryCommands = commandsToRegister;
+		while (retryCommands.length > 0) try {
+			await withTelegramApiErrorLogging({
+				operation: "setMyCommands",
+				runtime,
+				fn: () => bot.api.setMyCommands(retryCommands)
+			});
+			return;
+		} catch (err) {
+			if (!isBotCommandsTooMuchError(err)) throw err;
+			const nextCount = Math.floor(retryCommands.length * TELEGRAM_COMMAND_RETRY_RATIO);
+			const reducedCount = nextCount < retryCommands.length ? nextCount : retryCommands.length - 1;
+			if (reducedCount <= 0) {
+				runtime.error?.("Telegram rejected native command registration (BOT_COMMANDS_TOO_MUCH); leaving menu empty. Reduce commands or disable channels.telegram.commands.native.");
+				return;
+			}
+			runtime.log?.(`Telegram rejected ${retryCommands.length} commands (BOT_COMMANDS_TOO_MUCH); retrying with ${reducedCount}.`);
+			retryCommands = retryCommands.slice(0, reducedCount);
+		}
+	};
+	sync().catch((err) => {
+		runtime.error?.(`Telegram command sync failed: ${String(err)}`);
+	});
+}
+
+//#endregion
+//#region src/telegram/bot-native-commands.ts
+const EMPTY_RESPONSE_FALLBACK = "No response generated. Please try again.";
+async function resolveTelegramCommandAuth(params) {
+	const { msg, bot, cfg, accountId, telegramCfg, allowFrom, groupAllowFrom, useAccessGroups, resolveGroupPolicy, resolveTelegramGroupConfig, requireAuth } = params;
+	const chatId = msg.chat.id;
+	const isGroup = msg.chat.type === "group" || msg.chat.type === "supergroup";
+	const messageThreadId = msg.message_thread_id;
+	const isForum = msg.chat.is_forum === true;
+	const { resolvedThreadId, storeAllowFrom, groupConfig, topicConfig, effectiveGroupAllow, hasGroupAllowOverride } = await resolveTelegramGroupAllowFromContext({
+		chatId,
+		accountId,
+		isForum,
+		messageThreadId,
+		groupAllowFrom,
+		resolveTelegramGroupConfig
+	});
+	const senderId = msg.from?.id ? String(msg.from.id) : "";
+	const senderUsername = msg.from?.username ?? "";
+	const sendAuthMessage = async (text) => {
+		await withTelegramApiErrorLogging({
+			operation: "sendMessage",
+			fn: () => bot.api.sendMessage(chatId, text)
+		});
+		return null;
+	};
+	const rejectNotAuthorized = async () => {
+		return await sendAuthMessage("You are not authorized to use this command.");
+	};
+	const baseAccess = evaluateTelegramGroupBaseAccess({
+		isGroup,
+		groupConfig,
+		topicConfig,
+		hasGroupAllowOverride,
+		effectiveGroupAllow,
+		senderId,
+		senderUsername,
+		enforceAllowOverride: requireAuth,
+		requireSenderForAllowOverride: true
+	});
+	if (!baseAccess.allowed) {
+		if (baseAccess.reason === "group-disabled") return await sendAuthMessage("This group is disabled.");
+		if (baseAccess.reason === "topic-disabled") return await sendAuthMessage("This topic is disabled.");
+		return await rejectNotAuthorized();
+	}
+	const policyAccess = evaluateTelegramGroupPolicyAccess({
+		isGroup,
+		chatId,
+		cfg,
+		telegramCfg,
+		topicConfig,
+		groupConfig,
+		effectiveGroupAllow,
+		senderId,
+		senderUsername,
+		resolveGroupPolicy,
+		enforcePolicy: useAccessGroups,
+		useTopicAndGroupOverrides: false,
+		enforceAllowlistAuthorization: requireAuth,
+		allowEmptyAllowlistEntries: true,
+		requireSenderForAllowlistAuthorization: true,
+		checkChatAllowlist: useAccessGroups
+	});
+	if (!policyAccess.allowed) {
+		if (policyAccess.reason === "group-policy-disabled") return await sendAuthMessage("Telegram group commands are disabled.");
+		if (policyAccess.reason === "group-policy-allowlist-no-sender" || policyAccess.reason === "group-policy-allowlist-unauthorized") return await rejectNotAuthorized();
+		if (policyAccess.reason === "group-chat-not-allowed") return await sendAuthMessage("This group is not allowed.");
+	}
+	const dmAllow = normalizeDmAllowFromWithStore({
+		allowFrom,
+		storeAllowFrom: isGroup ? [] : storeAllowFrom,
+		dmPolicy: telegramCfg.dmPolicy ?? "pairing"
+	});
+	const senderAllowed = isSenderAllowed({
+		allow: dmAllow,
+		senderId,
+		senderUsername
+	});
+	const commandAuthorized = resolveCommandAuthorizedFromAuthorizers({
+		useAccessGroups,
+		authorizers: [{
+			configured: dmAllow.hasEntries,
+			allowed: senderAllowed
+		}],
+		modeWhenAccessGroupsOff: "configured"
+	});
+	if (requireAuth && !commandAuthorized) return await rejectNotAuthorized();
+	return {
+		chatId,
+		isGroup,
+		isForum,
+		resolvedThreadId,
+		senderId,
+		senderUsername,
+		groupConfig,
+		topicConfig,
+		commandAuthorized
+	};
+}
+const registerTelegramNativeCommands = ({ bot, cfg, runtime, accountId, telegramCfg, allowFrom, groupAllowFrom, replyToMode, textLimit, useAccessGroups, nativeEnabled, nativeSkillsEnabled, nativeDisabledExplicit, resolveGroupPolicy, resolveTelegramGroupConfig, shouldSkipUpdate, opts }) => {
+	const boundRoute = nativeEnabled && nativeSkillsEnabled ? resolveAgentRoute({
+		cfg,
+		channel: "telegram",
+		accountId
+	}) : null;
+	const boundAgentIds = boundRoute ? [boundRoute.agentId] : null;
+	const skillCommands = nativeEnabled && nativeSkillsEnabled ? listSkillCommandsForAgents(boundAgentIds ? {
+		cfg,
+		agentIds: boundAgentIds
+	} : { cfg }) : [];
+	const nativeCommands = nativeEnabled ? listNativeCommandSpecsForConfig(cfg, {
+		skillCommands,
+		provider: "telegram"
+	}) : [];
+	const reservedCommands = new Set(listNativeCommandSpecs().map((command) => normalizeTelegramCommandName(command.name)));
+	for (const command of skillCommands) reservedCommands.add(command.name.toLowerCase());
+	const customResolution = resolveTelegramCustomCommands({
+		commands: telegramCfg.customCommands,
+		reservedCommands
+	});
+	for (const issue of customResolution.issues) runtime.error?.(danger(issue.message));
+	const customCommands = customResolution.commands;
+	const pluginCatalog = buildPluginTelegramMenuCommands({
+		specs: getPluginCommandSpecs(),
+		existingCommands: new Set([...nativeCommands.map((command) => normalizeTelegramCommandName(command.name)), ...customCommands.map((command) => command.command)].map((command) => command.toLowerCase()))
+	});
+	for (const issue of pluginCatalog.issues) runtime.error?.(danger(issue));
+	const { commandsToRegister, totalCommands, maxCommands, overflowCount } = buildCappedTelegramMenuCommands({ allCommands: [
+		...nativeCommands.map((command) => {
+			const normalized = normalizeTelegramCommandName(command.name);
+			if (!TELEGRAM_COMMAND_NAME_PATTERN.test(normalized)) {
+				runtime.error?.(danger(`Native command "${command.name}" is invalid for Telegram (resolved to "${normalized}"). Skipping.`));
+				return null;
+			}
+			return {
+				command: normalized,
+				description: command.description
+			};
+		}).filter((cmd) => cmd !== null),
+		...nativeEnabled ? pluginCatalog.commands : [],
+		...customCommands
+	] });
+	if (overflowCount > 0) runtime.log?.(`Telegram limits bots to ${maxCommands} commands. ${totalCommands} configured; registering first ${maxCommands}. Use channels.telegram.commands.native: false to disable, or reduce plugin/skill/custom commands.`);
+	syncTelegramMenuCommands({
+		bot,
+		runtime,
+		commandsToRegister
+	});
+	const resolveCommandRuntimeContext = (params) => {
+		const { msg, isGroup, isForum, resolvedThreadId } = params;
+		const chatId = msg.chat.id;
+		const messageThreadId = msg.message_thread_id;
+		const threadSpec = resolveTelegramThreadSpec({
+			isGroup,
+			isForum,
+			messageThreadId
+		});
+		const parentPeer = buildTelegramParentPeer({
+			isGroup,
+			resolvedThreadId,
+			chatId
+		});
+		const route = resolveAgentRoute({
+			cfg,
+			channel: "telegram",
+			accountId,
+			peer: {
+				kind: isGroup ? "group" : "direct",
+				id: isGroup ? buildTelegramGroupPeerId(chatId, resolvedThreadId) : String(chatId)
+			},
+			parentPeer
+		});
+		return {
+			chatId,
+			threadSpec,
+			route,
+			mediaLocalRoots: getAgentScopedMediaLocalRoots(cfg, route.agentId),
+			tableMode: resolveMarkdownTableMode({
+				cfg,
+				channel: "telegram",
+				accountId: route.accountId
+			}),
+			chunkMode: resolveChunkMode(cfg, "telegram", route.accountId)
+		};
+	};
+	const buildCommandDeliveryBaseOptions = (params) => ({
+		chatId: String(params.chatId),
+		token: opts.token,
+		runtime,
+		bot,
+		mediaLocalRoots: params.mediaLocalRoots,
+		replyToMode,
+		textLimit,
+		thread: params.threadSpec,
+		tableMode: params.tableMode,
+		chunkMode: params.chunkMode,
+		linkPreview: telegramCfg.linkPreview
+	});
+	if (commandsToRegister.length > 0 || pluginCatalog.commands.length > 0) if (typeof bot.command !== "function") logVerbose("telegram: bot.command unavailable; skipping native handlers");
+	else {
+		for (const command of nativeCommands) {
+			const normalizedCommandName = normalizeTelegramCommandName(command.name);
+			bot.command(normalizedCommandName, async (ctx) => {
+				const msg = ctx.message;
+				if (!msg) return;
+				if (shouldSkipUpdate(ctx)) return;
+				const auth = await resolveTelegramCommandAuth({
+					msg,
+					bot,
+					cfg,
+					accountId,
+					telegramCfg,
+					allowFrom,
+					groupAllowFrom,
+					useAccessGroups,
+					resolveGroupPolicy,
+					resolveTelegramGroupConfig,
+					requireAuth: true
+				});
+				if (!auth) return;
+				const { chatId, isGroup, isForum, resolvedThreadId, senderId, senderUsername, groupConfig, topicConfig, commandAuthorized } = auth;
+				const { threadSpec, route, mediaLocalRoots, tableMode, chunkMode } = resolveCommandRuntimeContext({
+					msg,
+					isGroup,
+					isForum,
+					resolvedThreadId
+				});
+				const deliveryBaseOptions = buildCommandDeliveryBaseOptions({
+					chatId,
+					mediaLocalRoots,
+					threadSpec,
+					tableMode,
+					chunkMode
+				});
+				const threadParams = buildTelegramThreadParams(threadSpec) ?? {};
+				const commandDefinition = findCommandByNativeName(command.name, "telegram");
+				const rawText = ctx.match?.trim() ?? "";
+				const commandArgs = commandDefinition ? parseCommandArgs(commandDefinition, rawText) : rawText ? { raw: rawText } : void 0;
+				const prompt = commandDefinition ? buildCommandTextFromArgs(commandDefinition, commandArgs) : rawText ? `/${command.name} ${rawText}` : `/${command.name}`;
+				const menu = commandDefinition ? resolveCommandArgMenu({
+					command: commandDefinition,
+					args: commandArgs,
+					cfg
+				}) : null;
+				if (menu && commandDefinition) {
+					const title = menu.title ?? `Choose ${menu.arg.description || menu.arg.name} for /${commandDefinition.nativeName ?? commandDefinition.key}.`;
+					const rows = [];
+					for (let i = 0; i < menu.choices.length; i += 2) {
+						const slice = menu.choices.slice(i, i + 2);
+						rows.push(slice.map((choice) => {
+							const args = { values: { [menu.arg.name]: choice.value } };
+							return {
+								text: choice.label,
+								callback_data: buildCommandTextFromArgs(commandDefinition, args)
+							};
+						}));
+					}
+					const replyMarkup = buildInlineKeyboard(rows);
+					await withTelegramApiErrorLogging({
+						operation: "sendMessage",
+						runtime,
+						fn: () => bot.api.sendMessage(chatId, title, {
+							...replyMarkup ? { reply_markup: replyMarkup } : {},
+							...threadParams
+						})
+					});
+					return;
+				}
+				const baseSessionKey = route.sessionKey;
+				const dmThreadId = threadSpec.scope === "dm" ? threadSpec.id : void 0;
+				const sessionKey = (dmThreadId != null ? resolveThreadSessionKeys({
+					baseSessionKey,
+					threadId: String(dmThreadId)
+				}) : null)?.sessionKey ?? baseSessionKey;
+				const { skillFilter, groupSystemPrompt } = resolveTelegramGroupPromptSettings({
+					groupConfig,
+					topicConfig
+				});
+				const conversationLabel = isGroup ? msg.chat.title ? `${msg.chat.title} id:${chatId}` : `group:${chatId}` : buildSenderName(msg) ?? String(senderId || chatId);
+				const ctxPayload = finalizeInboundContext({
+					Body: prompt,
+					BodyForAgent: prompt,
+					RawBody: prompt,
+					CommandBody: prompt,
+					CommandArgs: commandArgs,
+					From: isGroup ? buildTelegramGroupFrom(chatId, resolvedThreadId) : `telegram:${chatId}`,
+					To: `slash:${senderId || chatId}`,
+					ChatType: isGroup ? "group" : "direct",
+					ConversationLabel: conversationLabel,
+					GroupSubject: isGroup ? msg.chat.title ?? void 0 : void 0,
+					GroupSystemPrompt: isGroup ? groupSystemPrompt : void 0,
+					SenderName: buildSenderName(msg),
+					SenderId: senderId || void 0,
+					SenderUsername: senderUsername || void 0,
+					Surface: "telegram",
+					Provider: "telegram",
+					MessageSid: String(msg.message_id),
+					Timestamp: msg.date ? msg.date * 1e3 : void 0,
+					WasMentioned: true,
+					CommandAuthorized: commandAuthorized,
+					CommandSource: "native",
+					SessionKey: `telegram:slash:${senderId || chatId}`,
+					AccountId: route.accountId,
+					CommandTargetSessionKey: sessionKey,
+					MessageThreadId: threadSpec.id,
+					IsForum: isForum,
+					OriginatingChannel: "telegram",
+					OriginatingTo: `telegram:${chatId}`
+				});
+				const storePath = resolveStorePath(cfg.session?.store, { agentId: route.agentId });
+				try {
+					await recordSessionMetaFromInbound({
+						storePath,
+						sessionKey: ctxPayload.SessionKey ?? route.sessionKey,
+						ctx: ctxPayload
+					});
+				} catch (err) {
+					runtime.error?.(danger(`telegram slash: failed updating session meta: ${String(err)}`));
+				}
+				const disableBlockStreaming = typeof telegramCfg.blockStreaming === "boolean" ? !telegramCfg.blockStreaming : void 0;
+				const deliveryState = {
+					delivered: false,
+					skippedNonSilent: 0
+				};
+				const { onModelSelected, ...prefixOptions } = createReplyPrefixOptions({
+					cfg,
+					agentId: route.agentId,
+					channel: "telegram",
+					accountId: route.accountId
+				});
+				await dispatchReplyWithBufferedBlockDispatcher({
+					ctx: ctxPayload,
+					cfg,
+					dispatcherOptions: {
+						...prefixOptions,
+						deliver: async (payload, _info) => {
+							if ((await deliverReplies({
+								replies: [payload],
+								...deliveryBaseOptions
+							})).delivered) deliveryState.delivered = true;
+						},
+						onSkip: (_payload, info) => {
+							if (info.reason !== "silent") deliveryState.skippedNonSilent += 1;
+						},
+						onError: (err, info) => {
+							runtime.error?.(danger(`telegram slash ${info.kind} reply failed: ${String(err)}`));
+						}
+					},
+					replyOptions: {
+						skillFilter,
+						disableBlockStreaming,
+						onModelSelected
+					}
+				});
+				if (!deliveryState.delivered && deliveryState.skippedNonSilent > 0) await deliverReplies({
+					replies: [{ text: EMPTY_RESPONSE_FALLBACK }],
+					...deliveryBaseOptions
+				});
+			});
+		}
+		for (const pluginCommand of pluginCatalog.commands) bot.command(pluginCommand.command, async (ctx) => {
+			const msg = ctx.message;
+			if (!msg) return;
+			if (shouldSkipUpdate(ctx)) return;
+			const chatId = msg.chat.id;
+			const rawText = ctx.match?.trim() ?? "";
+			const commandBody = `/${pluginCommand.command}${rawText ? ` ${rawText}` : ""}`;
+			const match = matchPluginCommand(commandBody);
+			if (!match) {
+				await withTelegramApiErrorLogging({
+					operation: "sendMessage",
+					runtime,
+					fn: () => bot.api.sendMessage(chatId, "Command not found.")
+				});
+				return;
+			}
+			const auth = await resolveTelegramCommandAuth({
+				msg,
+				bot,
+				cfg,
+				accountId,
+				telegramCfg,
+				allowFrom,
+				groupAllowFrom,
+				useAccessGroups,
+				resolveGroupPolicy,
+				resolveTelegramGroupConfig,
+				requireAuth: match.command.requireAuth !== false
+			});
+			if (!auth) return;
+			const { senderId, commandAuthorized, isGroup, isForum, resolvedThreadId } = auth;
+			const { threadSpec, mediaLocalRoots, tableMode, chunkMode } = resolveCommandRuntimeContext({
+				msg,
+				isGroup,
+				isForum,
+				resolvedThreadId
+			});
+			const deliveryBaseOptions = buildCommandDeliveryBaseOptions({
+				chatId,
+				mediaLocalRoots,
+				threadSpec,
+				tableMode,
+				chunkMode
+			});
+			const from = isGroup ? buildTelegramGroupFrom(chatId, threadSpec.id) : `telegram:${chatId}`;
+			const to = `telegram:${chatId}`;
+			await deliverReplies({
+				replies: [await executePluginCommand({
+					command: match.command,
+					args: match.args,
+					senderId,
+					channel: "telegram",
+					isAuthorizedSender: commandAuthorized,
+					commandBody,
+					config: cfg,
+					from,
+					to,
+					accountId,
+					messageThreadId: threadSpec.id
+				})],
+				...deliveryBaseOptions
+			});
+		});
+	}
+	else if (nativeDisabledExplicit) withTelegramApiErrorLogging({
+		operation: "setMyCommands",
+		runtime,
+		fn: () => bot.api.setMyCommands([])
+	}).catch(() => {});
+};
+
+//#endregion
+//#region src/telegram/sendchataction-401-backoff.ts
+const BACKOFF_POLICY = {
+	initialMs: 1e3,
+	maxMs: 3e5,
+	factor: 2,
+	jitter: .1
+};
+function is401Error(error) {
+	if (!error) return false;
+	const message = error instanceof Error ? error.message : JSON.stringify(error);
+	return message.includes("401") || message.toLowerCase().includes("unauthorized");
+}
+/**
+* Creates a GLOBAL (per-account) handler for sendChatAction that tracks 401 errors
+* across all message contexts. This prevents the infinite loop that caused Telegram
+* to delete bots (issue #27092).
+*
+* When a 401 occurs, exponential backoff is applied (1s → 2s → 4s → ... → 5min).
+* After maxConsecutive401 failures (default 10), all sendChatAction calls are
+* suspended until reset() is called.
+*/
+function createTelegramSendChatActionHandler({ sendChatActionFn, logger, maxConsecutive401 = 10 }) {
+	let consecutive401Failures = 0;
+	let suspended = false;
+	const reset = () => {
+		consecutive401Failures = 0;
+		suspended = false;
+	};
+	const sendChatAction = async (chatId, action, threadParams) => {
+		if (suspended) return;
+		if (consecutive401Failures > 0) {
+			const backoffMs = computeBackoff(BACKOFF_POLICY, consecutive401Failures);
+			logger(`sendChatAction backoff: waiting ${backoffMs}ms before retry (failure ${consecutive401Failures}/${maxConsecutive401})`);
+			await sleepWithAbort(backoffMs);
+		}
+		try {
+			await sendChatActionFn(chatId, action, threadParams);
+			if (consecutive401Failures > 0) {
+				logger(`sendChatAction recovered after ${consecutive401Failures} consecutive 401 failures`);
+				consecutive401Failures = 0;
+			}
+		} catch (error) {
+			if (is401Error(error)) {
+				consecutive401Failures++;
+				if (consecutive401Failures >= maxConsecutive401) {
+					suspended = true;
+					logger(`CRITICAL: sendChatAction suspended after ${consecutive401Failures} consecutive 401 errors. Bot token is likely invalid. Telegram may DELETE the bot if requests continue. Replace the token and restart: fased channels restart telegram`);
+				} else logger(`sendChatAction 401 error (${consecutive401Failures}/${maxConsecutive401}). Retrying with exponential backoff.`);
+			}
+			throw error;
+		}
+	};
+	return {
+		sendChatAction,
+		isSuspended: () => suspended,
+		reset
+	};
+}
+
+//#endregion
+//#region src/telegram/bot.ts
+const TELEGRAM_CONTROL_COMMANDS = new Set(["/status"]);
+function isTelegramControlRequestText(rawText, options) {
+	if (!rawText) return false;
+	if (isAbortRequestText(rawText, options)) return true;
+	const normalized = normalizeCommandBody(rawText, options).trim().toLowerCase();
+	return TELEGRAM_CONTROL_COMMANDS.has(normalized);
+}
+function getTelegramSequentialKey(ctx) {
+	const reaction = ctx.update?.message_reaction;
+	if (reaction?.chat?.id) return `telegram:${reaction.chat.id}`;
+	const msg = ctx.message ?? ctx.channelPost ?? ctx.editedChannelPost ?? ctx.update?.message ?? ctx.update?.edited_message ?? ctx.update?.channel_post ?? ctx.update?.edited_channel_post ?? ctx.update?.callback_query?.message;
+	const chatId = msg?.chat?.id ?? ctx.chat?.id;
+	const rawText = msg?.text ?? msg?.caption;
+	const botUsername = ctx.me?.username;
+	if (isTelegramControlRequestText(rawText, botUsername ? { botUsername } : void 0)) {
+		if (typeof chatId === "number") return `telegram:${chatId}:control`;
+		return "telegram:control";
+	}
+	const isGroup = msg?.chat?.type === "group" || msg?.chat?.type === "supergroup";
+	const messageThreadId = msg?.message_thread_id;
+	const isForum = msg?.chat?.is_forum;
+	const threadId = isGroup ? resolveTelegramForumThreadId({
+		isForum,
+		messageThreadId
+	}) : messageThreadId;
+	if (typeof chatId === "number") return threadId != null ? `telegram:${chatId}:topic:${threadId}` : `telegram:${chatId}`;
+	return "telegram:unknown";
+}
+function createTelegramBot(opts) {
+	const runtime = opts.runtime ?? createNonExitingRuntime();
+	const cfg = opts.config ?? loadConfig();
+	const account = resolveTelegramAccount({
+		cfg,
+		accountId: opts.accountId
+	});
+	const telegramCfg = account.config;
+	const fetchImpl = resolveTelegramFetch(opts.proxyFetch, { network: telegramCfg.network });
+	const shouldProvideFetch = Boolean(fetchImpl);
+	const fetchForClient = fetchImpl;
+	const timeoutSeconds = typeof telegramCfg?.timeoutSeconds === "number" && Number.isFinite(telegramCfg.timeoutSeconds) ? Math.max(1, Math.floor(telegramCfg.timeoutSeconds)) : void 0;
+	const client = shouldProvideFetch || timeoutSeconds ? {
+		...shouldProvideFetch && fetchImpl ? { fetch: fetchForClient } : {},
+		...timeoutSeconds ? { timeoutSeconds } : {}
+	} : void 0;
+	const bot = new Bot(opts.token, client ? { client } : void 0);
+	bot.api.config.use(apiThrottler());
+	bot.catch((err) => {
+		runtime.error?.(danger(`telegram bot error: ${formatUncaughtError(err)}`));
+	});
+	const recentUpdates = createTelegramUpdateDedupe();
+	const initialUpdateId = typeof opts.updateOffset?.lastUpdateId === "number" ? opts.updateOffset.lastUpdateId : null;
+	const pendingUpdateIds = /* @__PURE__ */ new Set();
+	let highestCompletedUpdateId = initialUpdateId;
+	let highestPersistedUpdateId = initialUpdateId;
+	const maybePersistSafeWatermark = () => {
+		if (typeof opts.updateOffset?.onUpdateId !== "function") return;
+		if (highestCompletedUpdateId === null) return;
+		let safe = highestCompletedUpdateId;
+		if (pendingUpdateIds.size > 0) {
+			let minPending = null;
+			for (const id of pendingUpdateIds) if (minPending === null || id < minPending) minPending = id;
+			if (minPending !== null) safe = Math.min(safe, minPending - 1);
+		}
+		if (highestPersistedUpdateId !== null && safe <= highestPersistedUpdateId) return;
+		highestPersistedUpdateId = safe;
+		opts.updateOffset.onUpdateId(safe);
+	};
+	const shouldSkipUpdate = (ctx) => {
+		const updateId = resolveTelegramUpdateId(ctx);
+		const skipCutoff = highestPersistedUpdateId ?? initialUpdateId;
+		if (typeof updateId === "number" && skipCutoff !== null && updateId <= skipCutoff) return true;
+		const key = buildTelegramUpdateKey(ctx);
+		const skipped = recentUpdates.check(key);
+		if (skipped && key && shouldLogVerbose()) logVerbose(`telegram dedupe: skipped ${key}`);
+		return skipped;
+	};
+	bot.use(async (ctx, next) => {
+		const updateId = resolveTelegramUpdateId(ctx);
+		if (typeof updateId === "number") pendingUpdateIds.add(updateId);
+		try {
+			await next();
+		} finally {
+			if (typeof updateId === "number") {
+				pendingUpdateIds.delete(updateId);
+				if (highestCompletedUpdateId === null || updateId > highestCompletedUpdateId) highestCompletedUpdateId = updateId;
+				maybePersistSafeWatermark();
+			}
+		}
+	});
+	bot.use(sequentialize(getTelegramSequentialKey));
+	const rawUpdateLogger = createSubsystemLogger("gateway/channels/telegram/raw-update");
+	const MAX_RAW_UPDATE_CHARS = 8e3;
+	const MAX_RAW_UPDATE_STRING = 500;
+	const MAX_RAW_UPDATE_ARRAY = 20;
+	const stringifyUpdate = (update) => {
+		const seen = /* @__PURE__ */ new WeakSet();
+		return JSON.stringify(update ?? null, (key, value) => {
+			if (typeof value === "string" && value.length > MAX_RAW_UPDATE_STRING) return `${value.slice(0, MAX_RAW_UPDATE_STRING)}...`;
+			if (Array.isArray(value) && value.length > MAX_RAW_UPDATE_ARRAY) return [...value.slice(0, MAX_RAW_UPDATE_ARRAY), `...(${value.length - MAX_RAW_UPDATE_ARRAY} more)`];
+			if (value && typeof value === "object") {
+				if (seen.has(value)) return "[Circular]";
+				seen.add(value);
+			}
+			return value;
+		});
+	};
+	bot.use(async (ctx, next) => {
+		if (shouldLogVerbose()) try {
+			const raw = stringifyUpdate(ctx.update);
+			const preview = raw.length > MAX_RAW_UPDATE_CHARS ? `${raw.slice(0, MAX_RAW_UPDATE_CHARS)}...` : raw;
+			rawUpdateLogger.debug(`telegram update: ${preview}`);
+		} catch (err) {
+			rawUpdateLogger.debug(`telegram update log failed: ${String(err)}`);
+		}
+		await next();
+	});
+	const historyLimit = Math.max(0, telegramCfg.historyLimit ?? cfg.messages?.groupChat?.historyLimit ?? DEFAULT_GROUP_HISTORY_LIMIT);
+	const groupHistories = /* @__PURE__ */ new Map();
+	const textLimit = resolveTextChunkLimit(cfg, "telegram", account.accountId);
+	const dmPolicy = telegramCfg.dmPolicy ?? "pairing";
+	const allowFrom = opts.allowFrom ?? telegramCfg.allowFrom;
+	const groupAllowFrom = opts.groupAllowFrom ?? telegramCfg.groupAllowFrom ?? (telegramCfg.allowFrom && telegramCfg.allowFrom.length > 0 ? telegramCfg.allowFrom : void 0) ?? (opts.allowFrom && opts.allowFrom.length > 0 ? opts.allowFrom : void 0);
+	const replyToMode = opts.replyToMode ?? telegramCfg.replyToMode ?? "off";
+	const nativeEnabled = resolveNativeCommandsEnabled({
+		providerId: "telegram",
+		providerSetting: telegramCfg.commands?.native,
+		globalSetting: cfg.commands?.native
+	});
+	const nativeSkillsEnabled = resolveNativeSkillsEnabled({
+		providerId: "telegram",
+		providerSetting: telegramCfg.commands?.nativeSkills,
+		globalSetting: cfg.commands?.nativeSkills
+	});
+	const nativeDisabledExplicit = isNativeCommandsExplicitlyDisabled({
+		providerSetting: telegramCfg.commands?.native,
+		globalSetting: cfg.commands?.native
+	});
+	const useAccessGroups = cfg.commands?.useAccessGroups !== false;
+	const ackReactionScope = cfg.messages?.ackReactionScope ?? "group-mentions";
+	const mediaMaxBytes = (opts.mediaMaxMb ?? telegramCfg.mediaMaxMb ?? 5) * 1024 * 1024;
+	const logger = getChildLogger({ module: "telegram-auto-reply" });
+	const streamMode = resolveTelegramStreamMode(telegramCfg);
+	const resolveGroupPolicy = (chatId) => resolveChannelGroupPolicy({
+		cfg,
+		channel: "telegram",
+		accountId: account.accountId,
+		groupId: String(chatId)
+	});
+	const resolveGroupActivation = (params) => {
+		const agentId = params.agentId ?? resolveDefaultAgentId(cfg);
+		const sessionKey = params.sessionKey ?? `agent:${agentId}:telegram:group:${buildTelegramGroupPeerId(params.chatId, params.messageThreadId)}`;
+		const storePath = resolveStorePath(cfg.session?.store, { agentId });
+		try {
+			const entry = loadSessionStore(storePath)[sessionKey];
+			if (entry?.groupActivation === "always") return false;
+			if (entry?.groupActivation === "mention") return true;
+		} catch (err) {
+			logVerbose(`Failed to load session for activation check: ${String(err)}`);
+		}
+	};
+	const resolveGroupRequireMention = (chatId) => resolveChannelGroupRequireMention({
+		cfg,
+		channel: "telegram",
+		accountId: account.accountId,
+		groupId: String(chatId),
+		requireMentionOverride: opts.requireMention,
+		overrideOrder: "after-config"
+	});
+	const resolveTelegramGroupConfig = (chatId, messageThreadId) => {
+		const groups = telegramCfg.groups;
+		if (!groups) return {
+			groupConfig: void 0,
+			topicConfig: void 0
+		};
+		const groupConfig = groups[String(chatId)] ?? groups["*"];
+		return {
+			groupConfig,
+			topicConfig: messageThreadId != null ? groupConfig?.topics?.[String(messageThreadId)] : void 0
+		};
+	};
+	const processMessage = createTelegramMessageProcessor({
+		bot,
+		cfg,
+		account,
+		telegramCfg,
+		historyLimit,
+		groupHistories,
+		dmPolicy,
+		allowFrom,
+		groupAllowFrom,
+		ackReactionScope,
+		logger,
+		resolveGroupActivation,
+		resolveGroupRequireMention,
+		resolveTelegramGroupConfig,
+		sendChatActionHandler: createTelegramSendChatActionHandler({
+			sendChatActionFn: (chatId, action, threadParams) => bot.api.sendChatAction(chatId, action, threadParams),
+			logger: (message) => logVerbose(`telegram: ${message}`)
+		}),
+		runtime,
+		replyToMode,
+		streamMode,
+		textLimit,
+		opts
+	});
+	registerTelegramNativeCommands({
+		bot,
+		cfg,
+		runtime,
+		accountId: account.accountId,
+		telegramCfg,
+		allowFrom,
+		groupAllowFrom,
+		replyToMode,
+		textLimit,
+		useAccessGroups,
+		nativeEnabled,
+		nativeSkillsEnabled,
+		nativeDisabledExplicit,
+		resolveGroupPolicy,
+		resolveTelegramGroupConfig,
+		shouldSkipUpdate,
+		opts
+	});
+	registerTelegramHandlers({
+		cfg,
+		accountId: account.accountId,
+		bot,
+		opts,
+		runtime,
+		mediaMaxBytes,
+		telegramCfg,
+		allowFrom,
+		groupAllowFrom,
+		resolveGroupPolicy,
+		resolveTelegramGroupConfig,
+		shouldSkipUpdate,
+		processMessage,
+		logger
+	});
+	return bot;
+}
+
+//#endregion
+//#region src/telegram/update-offset-store.ts
+const STORE_VERSION = 2;
+function normalizeAccountId(accountId) {
+	const trimmed = accountId?.trim();
+	if (!trimmed) return "default";
+	return trimmed.replace(/[^a-z0-9._-]+/gi, "_");
+}
+function resolveTelegramUpdateOffsetPath(accountId, env = process.env) {
+	const stateDir = resolveStateDir(env, os.homedir);
+	const normalized = normalizeAccountId(accountId);
+	return path.join(stateDir, "telegram", `update-offset-${normalized}.json`);
+}
+function extractBotIdFromToken(token) {
+	const trimmed = token?.trim();
+	if (!trimmed) return null;
+	const [rawBotId] = trimmed.split(":", 1);
+	if (!rawBotId || !/^\d+$/.test(rawBotId)) return null;
+	return rawBotId;
+}
+function safeParseState(raw) {
+	try {
+		const parsed = JSON.parse(raw);
+		if (parsed?.version !== STORE_VERSION && parsed?.version !== 1) return null;
+		if (parsed.lastUpdateId !== null && typeof parsed.lastUpdateId !== "number") return null;
+		if (parsed.version === STORE_VERSION && parsed.botId !== null && typeof parsed.botId !== "string") return null;
+		return {
+			version: STORE_VERSION,
+			lastUpdateId: parsed.lastUpdateId ?? null,
+			botId: parsed.version === STORE_VERSION ? parsed.botId ?? null : null
+		};
+	} catch {
+		return null;
+	}
+}
+async function readTelegramUpdateOffset(params) {
+	const filePath = resolveTelegramUpdateOffsetPath(params.accountId, params.env);
+	try {
+		const parsed = safeParseState(await fs.readFile(filePath, "utf-8"));
+		const expectedBotId = extractBotIdFromToken(params.botToken);
+		if (expectedBotId && parsed?.botId && parsed.botId !== expectedBotId) return null;
+		if (expectedBotId && parsed?.botId === null) return null;
+		return parsed?.lastUpdateId ?? null;
+	} catch (err) {
+		if (err.code === "ENOENT") return null;
+		return null;
+	}
+}
+async function writeTelegramUpdateOffset(params) {
+	const filePath = resolveTelegramUpdateOffsetPath(params.accountId, params.env);
+	const dir = path.dirname(filePath);
+	await fs.mkdir(dir, {
+		recursive: true,
+		mode: 448
+	});
+	const tmp = path.join(dir, `${path.basename(filePath)}.${crypto.randomUUID()}.tmp`);
+	const payload = {
+		version: STORE_VERSION,
+		lastUpdateId: params.updateId,
+		botId: extractBotIdFromToken(params.botToken)
+	};
+	await fs.writeFile(tmp, `${JSON.stringify(payload, null, 2)}\n`, { encoding: "utf-8" });
+	await fs.chmod(tmp, 384);
+	await fs.rename(tmp, filePath);
+}
+
+//#endregion
+//#region src/telegram/webhook.ts
+const TELEGRAM_WEBHOOK_MAX_BODY_BYTES = 1024 * 1024;
+const TELEGRAM_WEBHOOK_BODY_TIMEOUT_MS = 3e4;
+const TELEGRAM_WEBHOOK_CALLBACK_TIMEOUT_MS = 1e4;
+async function listenHttpServer(params) {
+	await new Promise((resolve, reject) => {
+		const onError = (err) => {
+			params.server.off("error", onError);
+			reject(err);
+		};
+		params.server.once("error", onError);
+		params.server.listen(params.port, params.host, () => {
+			params.server.off("error", onError);
+			resolve();
+		});
+	});
+}
+function resolveWebhookPublicUrl(params) {
+	if (params.configuredPublicUrl) return params.configuredPublicUrl;
+	const address = params.server.address();
+	if (address && typeof address !== "string") return `http://${params.host === "0.0.0.0" || address.address === "0.0.0.0" || address.address === "::" ? "localhost" : address.address}:${address.port}${params.path}`;
+	return `http://${params.host === "0.0.0.0" ? "localhost" : params.host}:${params.port}${params.path}`;
+}
+async function initializeTelegramWebhookBot(params) {
+	const initSignal = params.abortSignal;
+	await withTelegramApiErrorLogging({
+		operation: "getMe",
+		runtime: params.runtime,
+		fn: () => params.bot.init(initSignal)
+	});
+}
+async function startTelegramWebhook(opts) {
+	const path = opts.path ?? "/telegram-webhook";
+	const healthPath = opts.healthPath ?? "/healthz";
+	const port = opts.port ?? 8787;
+	const host = opts.host ?? "127.0.0.1";
+	const secret = typeof opts.secret === "string" ? opts.secret.trim() : "";
+	if (!secret) throw new Error("Telegram webhook mode requires a non-empty secret token. Set channels.telegram.webhookSecret in your config.");
+	const runtime = opts.runtime ?? defaultRuntime;
+	const diagnosticsEnabled = isDiagnosticsEnabled(opts.config);
+	const bot = createTelegramBot({
+		token: opts.token,
+		runtime,
+		proxyFetch: opts.fetch,
+		config: opts.config,
+		accountId: opts.accountId
+	});
+	await initializeTelegramWebhookBot({
+		bot,
+		runtime,
+		abortSignal: opts.abortSignal
+	});
+	const handler = webhookCallback(bot, "callback", {
+		secretToken: secret,
+		onTimeout: "return",
+		timeoutMilliseconds: TELEGRAM_WEBHOOK_CALLBACK_TIMEOUT_MS
+	});
+	if (diagnosticsEnabled) startDiagnosticHeartbeat();
+	const server = createServer((req, res) => {
+		const respondText = (statusCode, text = "") => {
+			if (res.headersSent || res.writableEnded) return;
+			res.writeHead(statusCode, { "Content-Type": "text/plain; charset=utf-8" });
+			res.end(text);
+		};
+		if (req.url === healthPath) {
+			res.writeHead(200);
+			res.end("ok");
+			return;
+		}
+		if (req.url !== path || req.method !== "POST") {
+			res.writeHead(404);
+			res.end();
+			return;
+		}
+		const startTime = Date.now();
+		if (diagnosticsEnabled) logWebhookReceived({
+			channel: "telegram",
+			updateType: "telegram-post"
+		});
+		(async () => {
+			const body = await readJsonBodyWithLimit(req, {
+				maxBytes: TELEGRAM_WEBHOOK_MAX_BODY_BYTES,
+				timeoutMs: TELEGRAM_WEBHOOK_BODY_TIMEOUT_MS,
+				emptyObjectOnEmpty: false
+			});
+			if (!body.ok) {
+				if (body.code === "PAYLOAD_TOO_LARGE") {
+					respondText(413, body.error);
+					return;
+				}
+				if (body.code === "REQUEST_BODY_TIMEOUT") {
+					respondText(408, body.error);
+					return;
+				}
+				if (body.code === "CONNECTION_CLOSED") {
+					respondText(400, body.error);
+					return;
+				}
+				respondText(400, body.error);
+				return;
+			}
+			let replied = false;
+			const reply = async (json) => {
+				if (replied) return;
+				replied = true;
+				if (res.headersSent || res.writableEnded) return;
+				res.writeHead(200, { "Content-Type": "application/json; charset=utf-8" });
+				res.end(json);
+			};
+			const unauthorized = async () => {
+				if (replied) return;
+				replied = true;
+				respondText(401, "unauthorized");
+			};
+			const secretHeaderRaw = req.headers["x-telegram-bot-api-secret-token"];
+			const secretHeader = Array.isArray(secretHeaderRaw) ? secretHeaderRaw[0] : secretHeaderRaw;
+			await handler(body.value, reply, secretHeader, unauthorized);
+			if (!replied) respondText(200);
+			if (diagnosticsEnabled) logWebhookProcessed({
+				channel: "telegram",
+				updateType: "telegram-post",
+				durationMs: Date.now() - startTime
+			});
+		})().catch((err) => {
+			const errMsg = formatErrorMessage(err);
+			if (diagnosticsEnabled) logWebhookError({
+				channel: "telegram",
+				updateType: "telegram-post",
+				error: errMsg
+			});
+			runtime.log?.(`webhook handler failed: ${errMsg}`);
+			respondText(500);
+		});
+	});
+	await listenHttpServer({
+		server,
+		port,
+		host
+	});
+	const boundAddress = server.address();
+	const boundPort = boundAddress && typeof boundAddress !== "string" ? boundAddress.port : port;
+	const publicUrl = resolveWebhookPublicUrl({
+		configuredPublicUrl: opts.publicUrl,
+		server,
+		path,
+		host,
+		port
+	});
+	try {
+		await withTelegramApiErrorLogging({
+			operation: "setWebhook",
+			runtime,
+			fn: () => bot.api.setWebhook(publicUrl, {
+				secret_token: secret,
+				allowed_updates: resolveTelegramAllowedUpdates()
+			})
+		});
+	} catch (err) {
+		server.close();
+		bot.stop();
+		if (diagnosticsEnabled) stopDiagnosticHeartbeat();
+		throw err;
+	}
+	runtime.log?.(`webhook local listener on http://${host}:${boundPort}${path}`);
+	runtime.log?.(`webhook advertised to telegram on ${publicUrl}`);
+	let shutDown = false;
+	const shutdown = () => {
+		if (shutDown) return;
+		shutDown = true;
+		withTelegramApiErrorLogging({
+			operation: "deleteWebhook",
+			runtime,
+			fn: () => bot.api.deleteWebhook({ drop_pending_updates: false })
+		}).catch(() => {});
+		server.close();
+		bot.stop();
+		if (diagnosticsEnabled) stopDiagnosticHeartbeat();
+	};
+	if (opts.abortSignal) opts.abortSignal.addEventListener("abort", shutdown, { once: true });
+	return {
+		server,
+		bot,
+		stop: shutdown
+	};
+}
+
+//#endregion
+//#region src/telegram/monitor.ts
+function createTelegramRunnerOptions(cfg) {
+	return {
+		sink: { concurrency: resolveAgentMaxConcurrent(cfg) },
+		runner: {
+			fetch: {
+				timeout: 30,
+				allowed_updates: resolveTelegramAllowedUpdates()
+			},
+			silent: true,
+			maxRetryTime: 3600 * 1e3,
+			retryInterval: "exponential"
+		}
+	};
+}
+const TELEGRAM_POLL_RESTART_POLICY = {
+	initialMs: 2e3,
+	maxMs: 3e4,
+	factor: 1.8,
+	jitter: .25
+};
+const isGetUpdatesConflict = (err) => {
+	if (!err || typeof err !== "object") return false;
+	const typed = err;
+	if ((typed.error_code ?? typed.errorCode) !== 409) return false;
+	return [
+		typed.method,
+		typed.description,
+		typed.message
+	].filter((value) => typeof value === "string").join(" ").toLowerCase().includes("getupdates");
+};
+/** Check if error is a Grammy HttpError (used to scope unhandled rejection handling) */
+const isGrammyHttpError = (err) => {
+	if (!err || typeof err !== "object") return false;
+	return err.name === "HttpError";
+};
+async function monitorTelegramProvider(opts = {}) {
+	const log = opts.runtime?.error ?? console.error;
+	let activeRunner;
+	let forceRestarted = false;
+	const unregisterHandler = registerUnhandledRejectionHandler((err) => {
+		const isNetworkError = isRecoverableTelegramNetworkError(err, { context: "polling" });
+		if (isGrammyHttpError(err) && isNetworkError) {
+			log(`[telegram] Suppressed network error: ${formatErrorMessage(err)}`);
+			return true;
+		}
+		if (isNetworkError && activeRunner && activeRunner.isRunning()) {
+			forceRestarted = true;
+			activeRunner.stop().catch(() => {});
+			log(`[telegram] Restarting polling after unhandled network error: ${formatErrorMessage(err)}`);
+			return true;
+		}
+		return false;
+	});
+	try {
+		const cfg = opts.config ?? loadConfig();
+		const account = resolveTelegramAccount({
+			cfg,
+			accountId: opts.accountId
+		});
+		const token = opts.token?.trim() || account.token;
+		if (!token) throw new Error(`Telegram bot token missing for account "${account.accountId}" (set channels.telegram.accounts.${account.accountId}.botToken/tokenFile or TELEGRAM_BOT_TOKEN for default).`);
+		const proxyFetch = opts.proxyFetch ?? (account.config.proxy ? makeProxyFetch(account.config.proxy) : void 0);
+		let lastUpdateId = await readTelegramUpdateOffset({
+			accountId: account.accountId,
+			botToken: token
+		});
+		const persistUpdateId = async (updateId) => {
+			if (lastUpdateId !== null && updateId <= lastUpdateId) return;
+			lastUpdateId = updateId;
+			try {
+				await writeTelegramUpdateOffset({
+					accountId: account.accountId,
+					updateId,
+					botToken: token
+				});
+			} catch (err) {
+				(opts.runtime?.error ?? console.error)(`telegram: failed to persist update offset: ${String(err)}`);
+			}
+		};
+		if (opts.useWebhook) {
+			await startTelegramWebhook({
+				token,
+				accountId: account.accountId,
+				config: cfg,
+				path: opts.webhookPath,
+				port: opts.webhookPort,
+				secret: opts.webhookSecret ?? account.config.webhookSecret,
+				host: opts.webhookHost ?? account.config.webhookHost,
+				runtime: opts.runtime,
+				fetch: proxyFetch,
+				abortSignal: opts.abortSignal,
+				publicUrl: opts.webhookUrl
+			});
+			await waitForAbortSignal(opts.abortSignal);
+			return;
+		}
+		let restartAttempts = 0;
+		let webhookCleared = false;
+		const runnerOptions = createTelegramRunnerOptions(cfg);
+		const waitBeforeRestart = async (buildLine) => {
+			restartAttempts += 1;
+			const delayMs = computeBackoff(TELEGRAM_POLL_RESTART_POLICY, restartAttempts);
+			log(buildLine(formatDurationPrecise(delayMs)));
+			try {
+				await sleepWithAbort(delayMs, opts.abortSignal);
+			} catch (sleepErr) {
+				if (opts.abortSignal?.aborted) return false;
+				throw sleepErr;
+			}
+			return true;
+		};
+		const waitBeforeRetryOnRecoverableSetupError = async (err, logPrefix) => {
+			if (opts.abortSignal?.aborted) return false;
+			if (!isRecoverableTelegramNetworkError(err, { context: "unknown" })) throw err;
+			return waitBeforeRestart((delay) => `${logPrefix}: ${formatErrorMessage(err)}; retrying in ${delay}.`);
+		};
+		const createPollingBot = async () => {
+			try {
+				return createTelegramBot({
+					token,
+					runtime: opts.runtime,
+					proxyFetch,
+					config: cfg,
+					accountId: account.accountId,
+					updateOffset: {
+						lastUpdateId,
+						onUpdateId: persistUpdateId
+					}
+				});
+			} catch (err) {
+				if (!await waitBeforeRetryOnRecoverableSetupError(err, "Telegram setup network error")) return;
+				return;
+			}
+		};
+		const ensureWebhookCleanup = async (bot) => {
+			if (webhookCleared) return "ready";
+			try {
+				await withTelegramApiErrorLogging({
+					operation: "deleteWebhook",
+					runtime: opts.runtime,
+					fn: () => bot.api.deleteWebhook({ drop_pending_updates: false })
+				});
+				webhookCleared = true;
+				return "ready";
+			} catch (err) {
+				return await waitBeforeRetryOnRecoverableSetupError(err, "Telegram webhook cleanup failed") ? "retry" : "exit";
+			}
+		};
+		const runPollingCycle = async (bot) => {
+			const runner = run(bot, runnerOptions);
+			activeRunner = runner;
+			let stopPromise;
+			const stopRunner = () => {
+				stopPromise ??= Promise.resolve(runner.stop()).then(() => void 0).catch(() => {});
+				return stopPromise;
+			};
+			const stopOnAbort = () => {
+				if (opts.abortSignal?.aborted) stopRunner();
+			};
+			opts.abortSignal?.addEventListener("abort", stopOnAbort, { once: true });
+			try {
+				await runner.task();
+				if (opts.abortSignal?.aborted) return "exit";
+				const reason = forceRestarted ? "unhandled network error" : "runner stopped (maxRetryTime exceeded or graceful stop)";
+				forceRestarted = false;
+				return await waitBeforeRestart((delay) => `Telegram polling runner stopped (${reason}); restarting in ${delay}.`) ? "continue" : "exit";
+			} catch (err) {
+				forceRestarted = false;
+				if (opts.abortSignal?.aborted) throw err;
+				const isConflict = isGetUpdatesConflict(err);
+				const isRecoverable = isRecoverableTelegramNetworkError(err, { context: "polling" });
+				if (!isConflict && !isRecoverable) throw err;
+				const reason = isConflict ? "getUpdates conflict" : "network error";
+				const errMsg = formatErrorMessage(err);
+				return await waitBeforeRestart((delay) => `Telegram ${reason}: ${errMsg}; retrying in ${delay}.`) ? "continue" : "exit";
+			} finally {
+				opts.abortSignal?.removeEventListener("abort", stopOnAbort);
+				await stopRunner();
+			}
+		};
+		while (!opts.abortSignal?.aborted) {
+			const bot = await createPollingBot();
+			if (!bot) continue;
+			const cleanupState = await ensureWebhookCleanup(bot);
+			if (cleanupState === "retry") continue;
+			if (cleanupState === "exit") return;
+			if (await runPollingCycle(bot) === "exit") return;
+		}
+	} finally {
+		unregisterHandler();
+	}
+}
+
+//#endregion
+export { monitorTelegramProvider };