@gaodefa/daocore 2026.5.71 → 2026.5.72

package/dist/delivery-DzhYKAIC.js

@@ -1,1002 +0,0 @@
-import { i as formatErrorMessage } from "./errors-D_oyTIw2.js";
-import { o as root } from "./secure-temp-dir-BC5cWiAo.js";
-import { r as logVerbose, s as warn, t as danger } from "./globals-DhGeOA1P.js";
-import { t as createSubsystemLogger } from "./subsystem-CppbuBPw.js";
-import { t as getGlobalHookRunner, u as fireAndForgetHook } from "./hook-runner-global-RR7B_IHd.js";
-import { m as triggerInternalHook, n as createInternalHookEvent } from "./internal-hooks-jFOLQ8JS.js";
-import { c as kindFromMime, s as isGifMedia } from "./mime-DppuT-pZ.js";
-import { a as toInternalMessageSentContext, d as toPluginMessageSentEvent, l as toPluginMessageContext, t as buildCanonicalSentMessageHookContext } from "./message-hook-mappers-Cts6cIjh.js";
-import { l as normalizeMessagePresentation } from "./payload-BDV15CYA.js";
-import { n as probeVideoDimensions } from "./media-services-C8kJ1LwP.js";
-import { a as projectOutboundPayloadPlanForDelivery, t as createOutboundPayloadPlan } from "./payloads-DecsNYNJ.js";
-import { u as saveMediaBuffer } from "./store-53qCOCD8.js";
-import { n as retryAsync } from "./retry-BKOOizpi.js";
-import { a as saveRemoteMedia, n as MediaFetchError } from "./fetch-CThiKx3T.js";
-import { t as loadWebMedia } from "./web-media-9RxiGagW.js";
-import { i as chunkMarkdownTextWithMode } from "./chunk-DeZRGIEM.js";
-import { t as buildOutboundMediaLoadOptions } from "./load-options-LnfEFXDj.js";
-import { i as shouldRetryTelegramTransportFallback, t as resolveTelegramApiBase } from "./fetch-CBRkqVBE.js";
-import "./runtime-env-BSECk1Nm.js";
-import { o as isSafeToRetrySendError, u as isTelegramRateLimitError } from "./request-timeouts-CQOVTeCu.js";
-import "./reply-chunking-C6CVu1PV.js";
-import "./web-media-CRJx89eu.js";
-import "./outbound-runtime-BWFKdtGY.js";
-import "./file-access-runtime-BFNHVWzb.js";
-import { n as createChannelApiRetryRunner } from "./retry-policy-NbhM9vPP.js";
-import "./ssrf-runtime-Gwgbj2qf.js";
-import "./media-runtime-CPXTkSQr.js";
-import "./plugin-runtime-TPqTSJyy.js";
-import "./hook-runtime-CUNYBlUz.js";
-import "./retry-runtime-BObvpQE1.js";
-import { B as resolveTelegramMediaPlaceholder, D as resolveTelegramReplyId, a as renderTelegramHtmlText, c as wrapFileReferencesInHtml, n as markdownToTelegramChunks, r as markdownToTelegramHtml } from "./format-BaYeBN8g.js";
-import { t as resolveTelegramInlineButtons } from "./button-types-C0Gyj4Tz.js";
-import { t as resolveTelegramInteractiveTextFallback } from "./interactive-fallback-hkNKT0cd.js";
-import { a as getCachedSticker, n as cacheSticker } from "./sticker-cache-B_K5GK1F.js";
-import { D as splitTelegramCaption, O as withTelegramApiErrorLogging, b as removeTelegramNativeQuoteParam, h as resolveTelegramVoiceSend, v as buildTelegramSendParams, x as buildInlineKeyboard, y as getTelegramNativeQuoteReplyMessageId } from "./send-CinwCGAp.js";
-import path from "node:path";
-import { GrammyError, InputFile } from "grammy";
-//#region extensions/telegram/src/bot/delivery.send.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 QUOTE_PARAM_RE = /\bquote not found\b|\bQUOTE_TEXT_INVALID\b|\bquote text invalid\b/i;
-const GrammyErrorCtor$2 = typeof GrammyError === "function" ? GrammyError : void 0;
-function isTelegramQuoteParamError(err) {
-	if (GrammyErrorCtor$2 && err instanceof GrammyErrorCtor$2) return QUOTE_PARAM_RE.test(err.description);
-	return QUOTE_PARAM_RE.test(formatErrorMessage(err));
-}
-function createTelegramDeliverySendRetry() {
-	return createChannelApiRetryRunner({
-		shouldRetry: (err) => isSafeToRetrySendError(err) || isTelegramRateLimitError(err),
-		strictShouldRetry: true
-	});
-}
-async function sendTelegramWithThreadFallback(params) {
-	const hasNativeQuote = getTelegramNativeQuoteReplyMessageId(params.requestParams) != null;
-	const shouldSuppressFirstErrorLog = (err) => hasNativeQuote && isTelegramQuoteParamError(err);
-	const mergedShouldLog = params.shouldLog ? (err) => params.shouldLog(err) && !shouldSuppressFirstErrorLog(err) : (err) => !shouldSuppressFirstErrorLog(err);
-	const requestWithRetry = createTelegramDeliverySendRetry();
-	const runLoggedSend = (operation, requestParams, shouldLog) => withTelegramApiErrorLogging({
-		operation,
-		runtime: params.runtime,
-		...shouldLog ? { shouldLog } : {},
-		fn: () => requestWithRetry(() => params.send(requestParams), operation)
-	});
-	try {
-		return await runLoggedSend(params.operation, params.requestParams, mergedShouldLog);
-	} catch (err) {
-		if (hasNativeQuote && isTelegramQuoteParamError(err)) {
-			params.runtime.log?.(`telegram ${params.operation}: native quote rejected; retrying with legacy reply_to_message_id`);
-			return await sendTelegramWithThreadFallback({
-				...params,
-				operation: `${params.operation} (legacy reply retry)`,
-				requestParams: removeTelegramNativeQuoteParam(params.requestParams)
-			});
-		}
-		throw err;
-	}
-}
-async function sendTelegramText(bot, chatId, text, runtime, opts) {
-	const baseParams = buildTelegramSendParams({
-		replyToMessageId: opts?.replyToMessageId,
-		replyQuoteMessageId: opts?.replyQuoteMessageId,
-		replyQuoteText: opts?.replyQuoteText,
-		replyQuotePosition: opts?.replyQuotePosition,
-		replyQuoteEntities: opts?.replyQuoteEntities,
-		thread: opts?.thread,
-		silent: opts?.silent
-	});
-	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 sendTelegramWithThreadFallback({
-			operation: "sendMessage",
-			runtime,
-			thread: opts?.thread,
-			requestParams: baseParams,
-			send: (effectiveParams) => bot.api.sendMessage(chatId, fallbackText, {
-				...linkPreviewOptions ? { link_preview_options: linkPreviewOptions } : {},
-				...opts?.replyMarkup ? { reply_markup: opts.replyMarkup } : {},
-				...effectiveParams
-			})
-		});
-		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 sendTelegramWithThreadFallback({
-			operation: "sendMessage",
-			runtime,
-			thread: opts?.thread,
-			requestParams: baseParams,
-			shouldLog: (err) => {
-				const errText = formatErrorMessage(err);
-				return !PARSE_ERR_RE.test(errText) && !EMPTY_TEXT_ERR_RE.test(errText);
-			},
-			send: (effectiveParams) => bot.api.sendMessage(chatId, htmlText, {
-				parse_mode: "HTML",
-				...linkPreviewOptions ? { link_preview_options: linkPreviewOptions } : {},
-				...opts?.replyMarkup ? { reply_markup: opts.replyMarkup } : {},
-				...effectiveParams
-			})
-		});
-		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 extensions/telegram/src/bot/reply-threading.ts
-function resolveReplyToForSend(params) {
-	return params.replyToId && (params.replyToMode === "all" || !params.progress.hasReplied) ? params.replyToId : void 0;
-}
-function markReplyApplied(progress, replyToId) {
-	if (replyToId && !progress.hasReplied) progress.hasReplied = true;
-}
-function markDelivered$1(progress) {
-	progress.hasDelivered = true;
-}
-async function sendChunkedTelegramReplyText(params) {
-	const applyDelivered = params.markDelivered ?? markDelivered$1;
-	for (let i = 0; i < params.chunks.length; i += 1) {
-		const chunk = params.chunks[i];
-		if (!chunk) continue;
-		const isFirstChunk = i === 0;
-		const replyToMessageId = resolveReplyToForSend({
-			replyToId: params.replyToId,
-			replyToMode: params.replyToMode,
-			progress: params.progress
-		});
-		const shouldAttachQuote = Boolean(replyToMessageId) && Boolean(params.replyQuoteText) && (params.quoteOnlyOnFirstChunk !== true || isFirstChunk);
-		await params.sendChunk({
-			chunk,
-			isFirstChunk,
-			replyToMessageId,
-			replyMarkup: isFirstChunk ? params.replyMarkup : void 0,
-			replyQuoteText: shouldAttachQuote ? params.replyQuoteText : void 0
-		});
-		markReplyApplied(params.progress, replyToMessageId);
-		applyDelivered(params.progress);
-	}
-}
-//#endregion
-//#region extensions/telegram/src/bot/delivery.replies.ts
-const VOICE_FORBIDDEN_MARKER = "VOICE_MESSAGES_FORBIDDEN";
-const CAPTION_TOO_LONG_RE = /caption is too long/i;
-const GrammyErrorCtor$1 = typeof GrammyError === "function" ? GrammyError : void 0;
-const silentReplyLogger = createSubsystemLogger("telegram/silent-reply");
-function buildChunkTextResolver(params) {
-	return (markdown) => {
-		const markdownChunks = params.chunkMode === "newline" ? chunkMarkdownTextWithMode(markdown, params.textLimit, params.chunkMode) : [markdown];
-		const chunks = [];
-		for (const chunk of markdownChunks) {
-			const nested = markdownToTelegramChunks(chunk, params.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;
-	};
-}
-function markDelivered(progress) {
-	progress.hasDelivered = true;
-	progress.deliveredCount += 1;
-}
-function filterEmptyTelegramTextChunks(chunks) {
-	return chunks.filter((chunk) => chunk.text.trim().length > 0);
-}
-function resolveReplyQuoteForSend(params) {
-	if (params.replyToId != null) {
-		const mapped = params.replyQuoteByMessageId?.[String(params.replyToId)];
-		if (mapped?.text) {
-			const quote = {
-				messageId: params.replyToId,
-				text: mapped.text
-			};
-			if (typeof mapped.position === "number") quote.position = mapped.position;
-			if (mapped.entities) quote.entities = mapped.entities;
-			return quote;
-		}
-	}
-	const quote = {};
-	if (params.replyQuoteMessageId != null) quote.messageId = params.replyQuoteMessageId;
-	if (params.replyQuoteText != null) quote.text = params.replyQuoteText;
-	if (params.replyQuotePosition != null) quote.position = params.replyQuotePosition;
-	if (params.replyQuoteEntities != null) quote.entities = params.replyQuoteEntities;
-	return quote;
-}
-async function deliverTextReply(params) {
-	let firstDeliveredMessageId;
-	await sendChunkedTelegramReplyText({
-		chunks: filterEmptyTelegramTextChunks(params.chunkText(params.replyText)),
-		progress: params.progress,
-		replyToId: params.replyToId,
-		replyToMode: params.replyToMode,
-		replyMarkup: params.replyMarkup,
-		replyQuoteText: params.replyQuoteText,
-		markDelivered,
-		sendChunk: async ({ chunk, replyToMessageId, replyMarkup, replyQuoteText }) => {
-			const messageId = await sendTelegramText(params.bot, params.chatId, chunk.html, params.runtime, {
-				replyToMessageId,
-				replyQuoteMessageId: params.replyQuoteMessageId,
-				replyQuoteText,
-				replyQuotePosition: params.replyQuotePosition,
-				replyQuoteEntities: params.replyQuoteEntities,
-				thread: params.thread,
-				textMode: "html",
-				plainText: chunk.text,
-				linkPreview: params.linkPreview,
-				silent: params.silent,
-				replyMarkup
-			});
-			if (firstDeliveredMessageId == null) firstDeliveredMessageId = messageId;
-		}
-	});
-	return firstDeliveredMessageId;
-}
-async function sendPendingFollowUpText(params) {
-	await sendChunkedTelegramReplyText({
-		chunks: filterEmptyTelegramTextChunks(params.chunkText(params.text)),
-		progress: params.progress,
-		replyToId: params.replyToId,
-		replyToMode: params.replyToMode,
-		replyMarkup: params.replyMarkup,
-		markDelivered,
-		sendChunk: async ({ chunk, replyToMessageId, replyMarkup }) => {
-			await sendTelegramText(params.bot, params.chatId, chunk.html, params.runtime, {
-				replyToMessageId,
-				thread: params.thread,
-				textMode: "html",
-				plainText: chunk.text,
-				linkPreview: params.linkPreview,
-				silent: params.silent,
-				replyMarkup
-			});
-		}
-	});
-}
-function isVoiceMessagesForbidden(err) {
-	if (GrammyErrorCtor$1 && err instanceof GrammyErrorCtor$1) return err.description.includes(VOICE_FORBIDDEN_MARKER);
-	return formatErrorMessage(err).includes(VOICE_FORBIDDEN_MARKER);
-}
-function isCaptionTooLong(err) {
-	if (GrammyErrorCtor$1 && err instanceof GrammyErrorCtor$1) return CAPTION_TOO_LONG_RE.test(err.description);
-	return CAPTION_TOO_LONG_RE.test(formatErrorMessage(err));
-}
-function resolveVoiceFallbackText(reply) {
-	if (reply.text?.trim()) return reply.text;
-	if (reply.spokenText?.trim()) return reply.spokenText;
-}
-async function sendTelegramVoiceFallbackText(opts) {
-	let firstDeliveredMessageId;
-	const chunks = filterEmptyTelegramTextChunks(opts.chunkText(opts.text));
-	let appliedReplyTo = false;
-	for (let i = 0; i < chunks.length; i += 1) {
-		const chunk = chunks[i];
-		const replyToForChunk = !appliedReplyTo ? opts.replyToId : void 0;
-		const applyQuoteForChunk = !appliedReplyTo;
-		const messageId = await sendTelegramText(opts.bot, opts.chatId, chunk.html, opts.runtime, {
-			replyToMessageId: replyToForChunk,
-			replyQuoteMessageId: applyQuoteForChunk ? opts.replyQuoteMessageId : void 0,
-			replyQuoteText: applyQuoteForChunk ? opts.replyQuoteText : void 0,
-			replyQuotePosition: applyQuoteForChunk ? opts.replyQuotePosition : void 0,
-			replyQuoteEntities: applyQuoteForChunk ? opts.replyQuoteEntities : void 0,
-			thread: opts.thread,
-			textMode: "html",
-			plainText: chunk.text,
-			linkPreview: opts.linkPreview,
-			silent: opts.silent,
-			replyMarkup: !appliedReplyTo ? opts.replyMarkup : void 0
-		});
-		if (firstDeliveredMessageId == null) firstDeliveredMessageId = messageId;
-		if (replyToForChunk) appliedReplyTo = true;
-	}
-	return firstDeliveredMessageId;
-}
-async function deliverMediaReply(params) {
-	let firstDeliveredMessageId;
-	let visibleFallbackText;
-	let first = true;
-	let pendingFollowUpText;
-	for (const mediaUrl of params.mediaList) {
-		const isFirstMedia = first;
-		const media = await params.mediaLoader(mediaUrl, buildOutboundMediaLoadOptions({
-			mediaLocalRoots: params.mediaLocalRoots,
-			maxBytes: params.mediaMaxBytes
-		}));
-		const kind = kindFromMime(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 ? params.reply.text ?? void 0 : void 0);
-		const htmlCaption = caption ? renderTelegramHtmlText(caption, { tableMode: params.tableMode }) : void 0;
-		if (followUpText) pendingFollowUpText = followUpText;
-		first = false;
-		const replyToMessageId = resolveReplyToForSend({
-			replyToId: params.replyToId,
-			replyToMode: params.replyToMode,
-			progress: params.progress
-		});
-		const shouldAttachButtonsToMedia = isFirstMedia && params.replyMarkup && !followUpText;
-		const videoDimensions = kind === "video" ? await probeVideoDimensions(media.buffer) : void 0;
-		const mediaParams = {
-			caption: htmlCaption,
-			...htmlCaption ? { parse_mode: "HTML" } : {},
-			...shouldAttachButtonsToMedia ? { reply_markup: params.replyMarkup } : {},
-			...videoDimensions ? {
-				width: videoDimensions.width,
-				height: videoDimensions.height
-			} : {},
-			...buildTelegramSendParams({
-				replyToMessageId,
-				replyQuoteMessageId: params.replyQuoteMessageId,
-				replyQuoteText: params.replyQuoteText,
-				replyQuotePosition: params.replyQuotePosition,
-				replyQuoteEntities: params.replyQuoteEntities,
-				thread: params.thread,
-				silent: params.silent
-			})
-		};
-		if (isGif) {
-			const result = await sendTelegramWithThreadFallback({
-				operation: "sendAnimation",
-				runtime: params.runtime,
-				thread: params.thread,
-				requestParams: mediaParams,
-				send: (effectiveParams) => params.bot.api.sendAnimation(params.chatId, file, { ...effectiveParams })
-			});
-			if (firstDeliveredMessageId == null) firstDeliveredMessageId = result.message_id;
-			markDelivered(params.progress);
-		} else if (kind === "image") {
-			const result = await sendTelegramWithThreadFallback({
-				operation: "sendPhoto",
-				runtime: params.runtime,
-				thread: params.thread,
-				requestParams: mediaParams,
-				send: (effectiveParams) => params.bot.api.sendPhoto(params.chatId, file, { ...effectiveParams })
-			});
-			if (firstDeliveredMessageId == null) firstDeliveredMessageId = result.message_id;
-			markDelivered(params.progress);
-		} else if (kind === "video") {
-			const result = await sendTelegramWithThreadFallback({
-				operation: "sendVideo",
-				runtime: params.runtime,
-				thread: params.thread,
-				requestParams: mediaParams,
-				send: (effectiveParams) => params.bot.api.sendVideo(params.chatId, file, { ...effectiveParams })
-			});
-			if (firstDeliveredMessageId == null) firstDeliveredMessageId = result.message_id;
-			markDelivered(params.progress);
-		} else if (kind === "audio") {
-			const { useVoice } = resolveTelegramVoiceSend({
-				wantsVoice: params.reply.audioAsVoice === true,
-				contentType: media.contentType,
-				fileName,
-				logFallback: logVerbose
-			});
-			if (useVoice) {
-				const sendVoiceMedia = async (requestParams, shouldLog) => {
-					const result = await sendTelegramWithThreadFallback({
-						operation: "sendVoice",
-						runtime: params.runtime,
-						thread: params.thread,
-						requestParams,
-						shouldLog,
-						send: (effectiveParams) => params.bot.api.sendVoice(params.chatId, file, { ...effectiveParams })
-					});
-					if (firstDeliveredMessageId == null) firstDeliveredMessageId = result.message_id;
-					markDelivered(params.progress);
-				};
-				await params.onVoiceRecording?.();
-				try {
-					await sendVoiceMedia(mediaParams, (err) => !isVoiceMessagesForbidden(err));
-				} catch (voiceErr) {
-					if (isVoiceMessagesForbidden(voiceErr)) {
-						const fallbackText = resolveVoiceFallbackText(params.reply);
-						if (!fallbackText || !fallbackText.trim()) throw voiceErr;
-						logVerbose("telegram sendVoice forbidden (recipient has voice messages blocked in privacy settings); falling back to text");
-						const voiceFallbackReplyTo = resolveReplyToForSend({
-							replyToId: params.replyToId,
-							replyToMode: params.replyToMode,
-							progress: params.progress
-						});
-						const fallbackMessageId = await sendTelegramVoiceFallbackText({
-							bot: params.bot,
-							chatId: params.chatId,
-							runtime: params.runtime,
-							text: fallbackText,
-							chunkText: params.chunkText,
-							replyToId: voiceFallbackReplyTo,
-							replyQuoteMessageId: params.replyQuoteMessageId,
-							replyQuotePosition: params.replyQuotePosition,
-							replyQuoteEntities: params.replyQuoteEntities,
-							thread: params.thread,
-							linkPreview: params.linkPreview,
-							silent: params.silent,
-							replyMarkup: params.replyMarkup,
-							replyQuoteText: params.replyQuoteText
-						});
-						if (firstDeliveredMessageId == null) firstDeliveredMessageId = fallbackMessageId;
-						visibleFallbackText = fallbackText;
-						markReplyApplied(params.progress, voiceFallbackReplyTo);
-						markDelivered(params.progress);
-						continue;
-					}
-					if (isCaptionTooLong(voiceErr)) {
-						logVerbose("telegram sendVoice caption too long; resending voice without caption + text separately");
-						const noCaptionParams = { ...mediaParams };
-						delete noCaptionParams.caption;
-						delete noCaptionParams.parse_mode;
-						await sendVoiceMedia(noCaptionParams);
-						const fallbackText = resolveVoiceFallbackText(params.reply);
-						if (fallbackText?.trim()) {
-							await sendTelegramVoiceFallbackText({
-								bot: params.bot,
-								chatId: params.chatId,
-								runtime: params.runtime,
-								text: fallbackText,
-								chunkText: params.chunkText,
-								replyToId: void 0,
-								thread: params.thread,
-								linkPreview: params.linkPreview,
-								silent: params.silent,
-								replyMarkup: params.replyMarkup
-							});
-							visibleFallbackText = fallbackText;
-						}
-						markReplyApplied(params.progress, replyToMessageId);
-						continue;
-					}
-					throw voiceErr;
-				}
-			} else {
-				const result = await sendTelegramWithThreadFallback({
-					operation: "sendAudio",
-					runtime: params.runtime,
-					thread: params.thread,
-					requestParams: mediaParams,
-					send: (effectiveParams) => params.bot.api.sendAudio(params.chatId, file, { ...effectiveParams })
-				});
-				if (firstDeliveredMessageId == null) firstDeliveredMessageId = result.message_id;
-				markDelivered(params.progress);
-			}
-		} else {
-			const result = await sendTelegramWithThreadFallback({
-				operation: "sendDocument",
-				runtime: params.runtime,
-				thread: params.thread,
-				requestParams: mediaParams,
-				send: (effectiveParams) => params.bot.api.sendDocument(params.chatId, file, { ...effectiveParams })
-			});
-			if (firstDeliveredMessageId == null) firstDeliveredMessageId = result.message_id;
-			markDelivered(params.progress);
-		}
-		markReplyApplied(params.progress, replyToMessageId);
-		if (pendingFollowUpText && isFirstMedia) {
-			await sendPendingFollowUpText({
-				bot: params.bot,
-				chatId: params.chatId,
-				runtime: params.runtime,
-				thread: params.thread,
-				chunkText: params.chunkText,
-				text: pendingFollowUpText,
-				replyMarkup: params.replyMarkup,
-				linkPreview: params.linkPreview,
-				silent: params.silent,
-				replyToId: params.replyToId,
-				replyToMode: params.replyToMode,
-				progress: params.progress
-			});
-			pendingFollowUpText = void 0;
-		}
-	}
-	return {
-		firstDeliveredMessageId,
-		visibleFallbackText
-	};
-}
-async function maybePinFirstDeliveredMessage(params) {
-	if (!(params.pin === true || typeof params.pin === "object" && params.pin.enabled) || typeof params.firstDeliveredMessageId !== "number") return;
-	const notify = typeof params.pin === "object" && params.pin.notify === true;
-	try {
-		await params.bot.api.pinChatMessage(params.chatId, params.firstDeliveredMessageId, { disable_notification: !notify });
-	} catch (err) {
-		logVerbose(`telegram pinChatMessage failed chat=${params.chatId} message=${params.firstDeliveredMessageId}: ${formatErrorMessage(err)}`);
-	}
-}
-function buildTelegramSentHookContext(params) {
-	return buildCanonicalSentMessageHookContext({
-		to: params.chatId,
-		content: params.content,
-		success: params.success,
-		error: params.error,
-		channelId: "telegram",
-		accountId: params.accountId,
-		conversationId: params.chatId,
-		messageId: typeof params.messageId === "number" ? String(params.messageId) : void 0,
-		isGroup: params.isGroup,
-		groupId: params.groupId
-	});
-}
-function emitInternalMessageSentHook(params) {
-	if (!params.sessionKeyForInternalHooks) return;
-	const canonical = buildTelegramSentHookContext(params);
-	fireAndForgetHook(triggerInternalHook(createInternalHookEvent("message", "sent", params.sessionKeyForInternalHooks, toInternalMessageSentContext(canonical))), "telegram: message:sent internal hook failed");
-}
-function emitMessageSentHooks(params) {
-	if (!params.enabled && !params.sessionKeyForInternalHooks) return;
-	const canonical = buildTelegramSentHookContext(params);
-	if (params.enabled) fireAndForgetHook(Promise.resolve(params.hookRunner.runMessageSent(toPluginMessageSentEvent(canonical), toPluginMessageContext(canonical))), "telegram: message_sent plugin hook failed");
-	emitInternalMessageSentHook(params);
-}
-function emitTelegramMessageSentHooks(params) {
-	const hookRunner = getGlobalHookRunner();
-	emitMessageSentHooks({
-		...params,
-		hookRunner,
-		enabled: hookRunner?.hasHooks("message_sent") ?? false
-	});
-}
-async function deliverReplies(params) {
-	const progress = {
-		hasReplied: false,
-		hasDelivered: false,
-		deliveredCount: 0
-	};
-	const mediaLoader = params.mediaLoader ?? loadWebMedia;
-	const transcriptMirror = params.transcriptMirror;
-	const deliveredContents = [];
-	const hookRunner = getGlobalHookRunner();
-	const hasMessageSendingHooks = hookRunner?.hasHooks("message_sending") ?? false;
-	const hasMessageSentHooks = hookRunner?.hasHooks("message_sent") ?? false;
-	const chunkText = buildChunkTextResolver({
-		textLimit: params.textLimit,
-		chunkMode: params.chunkMode ?? "length",
-		tableMode: params.tableMode
-	});
-	const candidateReplies = [];
-	for (const reply of params.replies) {
-		if (!reply || typeof reply !== "object") {
-			params.runtime.error?.(danger("reply missing text/media"));
-			continue;
-		}
-		candidateReplies.push(reply);
-	}
-	const normalizedReplies = projectOutboundPayloadPlanForDelivery(createOutboundPayloadPlan(candidateReplies, {
-		cfg: params.cfg,
-		sessionKey: params.policySessionKey ?? params.sessionKeyForInternalHooks,
-		surface: "telegram"
-	}));
-	const originalExactSilentCount = candidateReplies.filter((reply) => typeof reply.text === "string" && reply.text.trim().toUpperCase() === "NO_REPLY").length;
-	if (originalExactSilentCount > 0) silentReplyLogger.debug("telegram delivery normalized NO_REPLY candidates", {
-		hasSessionKey: Boolean(params.sessionKeyForInternalHooks),
-		hasChatId: params.chatId.length > 0,
-		originalCount: candidateReplies.length,
-		normalizedCount: normalizedReplies.length,
-		originalExactSilentCount
-	});
-	for (const originalReply of normalizedReplies) {
-		let reply = originalReply;
-		const mediaList = reply?.mediaUrls?.length ? reply.mediaUrls : reply?.mediaUrl ? [reply.mediaUrl] : [];
-		const hasMedia = mediaList.length > 0;
-		const presentation = normalizeMessagePresentation(reply?.presentation);
-		const interactive = reply?.interactive;
-		const resolvedReplyText = resolveTelegramInteractiveTextFallback({
-			text: reply?.text,
-			interactive,
-			presentation
-		}) ?? reply?.text ?? "";
-		if (reply && resolvedReplyText !== (reply.text ?? "")) reply = {
-			...reply,
-			text: resolvedReplyText
-		};
-		if (!resolvedReplyText && !hasMedia) {
-			if (reply?.audioAsVoice) {
-				logVerbose("telegram reply has audioAsVoice without media/text; skipping");
-				continue;
-			}
-			params.runtime.error?.(danger("reply missing text/media"));
-			continue;
-		}
-		const rawContent = resolvedReplyText;
-		const spokenHookContent = !rawContent && reply.audioAsVoice === true && reply.spokenText?.trim() ? reply.spokenText : void 0;
-		const hookContent = spokenHookContent ?? rawContent;
-		const replyToId = params.replyToMode === "off" ? void 0 : resolveTelegramReplyId(reply.replyToId);
-		const replyQuote = resolveReplyQuoteForSend({
-			replyToId,
-			replyQuoteByMessageId: params.replyQuoteByMessageId,
-			replyQuoteMessageId: params.replyQuoteMessageId,
-			replyQuoteText: params.replyQuoteText,
-			replyQuotePosition: params.replyQuotePosition,
-			replyQuoteEntities: params.replyQuoteEntities
-		});
-		if (hasMessageSendingHooks) {
-			const hookResult = await hookRunner?.runMessageSending({
-				to: params.chatId,
-				content: hookContent,
-				replyToId,
-				threadId: params.thread?.id,
-				metadata: {
-					channel: "telegram",
-					mediaUrls: mediaList,
-					threadId: params.thread?.id
-				}
-			}, {
-				channelId: "telegram",
-				accountId: params.accountId,
-				conversationId: params.chatId
-			});
-			if (hookResult?.cancel) continue;
-			if (typeof hookResult?.content === "string" && hookResult.content !== hookContent) reply = spokenHookContent ? {
-				...reply,
-				spokenText: hookResult.content
-			} : {
-				...reply,
-				text: hookResult.content
-			};
-		}
-		let contentForSentHook = reply.text || (reply.audioAsVoice === true ? resolveVoiceFallbackText(reply) : "") || "";
-		try {
-			const deliveredCountBeforeReply = progress.deliveredCount;
-			const telegramData = reply.channelData?.telegram;
-			const replyMarkup = buildInlineKeyboard(resolveTelegramInlineButtons({
-				buttons: telegramData?.buttons,
-				presentation,
-				interactive
-			}));
-			let firstDeliveredMessageId;
-			if (mediaList.length === 0) firstDeliveredMessageId = await deliverTextReply({
-				bot: params.bot,
-				chatId: params.chatId,
-				runtime: params.runtime,
-				thread: params.thread,
-				chunkText,
-				replyText: reply.text || "",
-				replyMarkup,
-				replyQuoteMessageId: replyQuote.messageId,
-				replyQuoteText: replyQuote.text,
-				replyQuotePosition: replyQuote.position,
-				replyQuoteEntities: replyQuote.entities,
-				linkPreview: params.linkPreview,
-				silent: params.silent,
-				replyToId,
-				replyToMode: params.replyToMode,
-				progress
-			});
-			else {
-				const mediaDelivery = await deliverMediaReply({
-					reply,
-					mediaList,
-					bot: params.bot,
-					chatId: params.chatId,
-					runtime: params.runtime,
-					thread: params.thread,
-					tableMode: params.tableMode,
-					mediaLocalRoots: params.mediaLocalRoots,
-					mediaMaxBytes: params.mediaMaxBytes,
-					chunkText,
-					mediaLoader,
-					onVoiceRecording: params.onVoiceRecording,
-					linkPreview: params.linkPreview,
-					silent: params.silent,
-					replyQuoteMessageId: replyQuote.messageId,
-					replyQuoteText: replyQuote.text,
-					replyQuotePosition: replyQuote.position,
-					replyQuoteEntities: replyQuote.entities,
-					replyMarkup,
-					replyToId,
-					replyToMode: params.replyToMode,
-					progress
-				});
-				firstDeliveredMessageId = mediaDelivery.firstDeliveredMessageId;
-				if (mediaDelivery.visibleFallbackText) contentForSentHook = mediaDelivery.visibleFallbackText;
-			}
-			await maybePinFirstDeliveredMessage({
-				pin: reply.delivery?.pin,
-				bot: params.bot,
-				chatId: params.chatId,
-				runtime: params.runtime,
-				firstDeliveredMessageId
-			});
-			if (progress.deliveredCount > deliveredCountBeforeReply && transcriptMirror) deliveredContents.push({
-				text: contentForSentHook,
-				mediaUrls: mediaList
-			});
-			emitMessageSentHooks({
-				hookRunner,
-				enabled: hasMessageSentHooks,
-				sessionKeyForInternalHooks: params.sessionKeyForInternalHooks,
-				chatId: params.chatId,
-				accountId: params.accountId,
-				content: contentForSentHook,
-				success: progress.deliveredCount > deliveredCountBeforeReply,
-				messageId: firstDeliveredMessageId,
-				isGroup: params.mirrorIsGroup,
-				groupId: params.mirrorGroupId
-			});
-		} catch (error) {
-			emitMessageSentHooks({
-				hookRunner,
-				enabled: hasMessageSentHooks,
-				sessionKeyForInternalHooks: params.sessionKeyForInternalHooks,
-				chatId: params.chatId,
-				accountId: params.accountId,
-				content: contentForSentHook,
-				success: false,
-				error: formatErrorMessage(error),
-				isGroup: params.mirrorIsGroup,
-				groupId: params.mirrorGroupId
-			});
-			throw error;
-		}
-	}
-	if (progress.hasDelivered && transcriptMirror) {
-		const text = deliveredContents.map((content) => content.text).filter(Boolean).join("\n\n");
-		const mediaUrls = deliveredContents.flatMap((content) => content.mediaUrls);
-		if (text || mediaUrls.length > 0) try {
-			await transcriptMirror({
-				text: text || void 0,
-				mediaUrls: mediaUrls.length > 0 ? mediaUrls : void 0
-			});
-		} catch (mirrorErr) {
-			logVerbose(`telegram transcriptMirror failed: ${formatErrorMessage(mirrorErr)}`);
-		}
-	}
-	return { delivered: progress.hasDelivered };
-}
-//#endregion
-//#region extensions/telegram/src/bot/delivery.resolve-media.ts
-const FILE_TOO_BIG_RE = /file is too big/i;
-const GrammyErrorCtor = typeof GrammyError === "function" ? GrammyError : void 0;
-function buildTelegramMediaSsrfPolicy(apiRoot, dangerouslyAllowPrivateNetwork) {
-	const hostnames = ["api.telegram.org"];
-	let allowedHostnames;
-	if (apiRoot) try {
-		const customHost = new URL(apiRoot).hostname;
-		if (customHost && !hostnames.includes(customHost)) {
-			hostnames.push(customHost);
-			allowedHostnames = [customHost];
-		}
-	} catch (err) {
-		logVerbose(`telegram: invalid apiRoot URL "${apiRoot}": ${String(err)}`);
-	}
-	return {
-		hostnameAllowlist: hostnames,
-		...allowedHostnames ? { allowedHostnames } : {},
-		...dangerouslyAllowPrivateNetwork ? { allowPrivateNetwork: true } : {},
-		allowRfc2544BenchmarkRange: true
-	};
-}
-/**
-* 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 (GrammyErrorCtor && err instanceof GrammyErrorCtor) 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;
-}
-function resolveMediaMetadata(msg) {
-	return {
-		fileRef: msg.photo?.[msg.photo.length - 1] ?? msg.video ?? msg.video_note ?? msg.document ?? msg.audio ?? msg.voice,
-		fileName: msg.document?.file_name ?? msg.audio?.file_name ?? msg.video?.file_name ?? msg.animation?.file_name,
-		mimeType: msg.audio?.mime_type ?? msg.voice?.mime_type ?? msg.video?.mime_type ?? msg.document?.mime_type ?? msg.animation?.mime_type
-	};
-}
-async function resolveTelegramFileWithRetry(ctx) {
-	try {
-		return 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;
-	}
-}
-function resolveRequiredTelegramTransport(transport) {
-	if (transport) return transport;
-	const resolvedFetch = globalThis.fetch;
-	if (!resolvedFetch) throw new Error("fetch is not available; set channels.telegram.proxy in config");
-	return {
-		fetch: resolvedFetch,
-		sourceFetch: resolvedFetch,
-		close: async () => {}
-	};
-}
-/** Default idle timeout for Telegram media downloads (30 seconds). */
-const TELEGRAM_DOWNLOAD_IDLE_TIMEOUT_MS = 3e4;
-function usesTrustedTelegramExplicitProxy(transport) {
-	return transport.dispatcherAttempts?.some((attempt) => attempt.dispatcherPolicy?.mode === "explicit-proxy") ?? false;
-}
-function resolveTrustedLocalTelegramRoot(filePath, trustedLocalFileRoots) {
-	if (!path.isAbsolute(filePath)) return null;
-	for (const rootDir of trustedLocalFileRoots ?? []) {
-		const relativePath = path.relative(rootDir, filePath);
-		if (relativePath === "" || relativePath === ".." || relativePath.startsWith(`..${path.sep}`) || path.isAbsolute(relativePath)) continue;
-		return {
-			rootDir,
-			relativePath
-		};
-	}
-	return null;
-}
-async function downloadAndSaveTelegramFile(params) {
-	const trustedLocalFile = resolveTrustedLocalTelegramRoot(params.filePath, params.trustedLocalFileRoots);
-	if (trustedLocalFile) {
-		let localFile;
-		try {
-			localFile = await (await root(trustedLocalFile.rootDir)).read(trustedLocalFile.relativePath, { maxBytes: params.maxBytes });
-		} catch (err) {
-			throw new MediaFetchError("fetch_failed", `Failed to read local Telegram Bot API media from ${params.filePath}: ${formatErrorMessage(err)}`, { cause: err });
-		}
-		return await saveMediaBuffer(localFile.buffer, params.mimeType, "inbound", params.maxBytes, params.telegramFileName ?? path.basename(localFile.realPath));
-	}
-	if (path.isAbsolute(params.filePath)) throw new MediaFetchError("fetch_failed", `Telegram Bot API returned absolute file path ${params.filePath} outside trustedLocalFileRoots`);
-	const transport = resolveRequiredTelegramTransport(params.transport);
-	return await saveRemoteMedia({
-		url: `${resolveTelegramApiBase(params.apiRoot)}/file/bot${params.token}/${params.filePath}`,
-		fetchImpl: transport.sourceFetch,
-		dispatcherAttempts: transport.dispatcherAttempts,
-		trustExplicitProxyDns: usesTrustedTelegramExplicitProxy(transport),
-		shouldRetryFetchError: shouldRetryTelegramTransportFallback,
-		retry: {
-			attempts: 3,
-			minDelayMs: 1e3,
-			maxDelayMs: 4e3,
-			jitter: .2,
-			label: "telegram:media-download",
-			onRetry: ({ attempt, maxAttempts }) => logVerbose(`telegram: media download retry ${attempt}/${maxAttempts}`)
-		},
-		filePathHint: params.filePath,
-		maxBytes: params.maxBytes,
-		readIdleTimeoutMs: TELEGRAM_DOWNLOAD_IDLE_TIMEOUT_MS,
-		ssrfPolicy: buildTelegramMediaSsrfPolicy(params.apiRoot, params.dangerouslyAllowPrivateNetwork),
-		fallbackContentType: params.mimeType,
-		originalFilename: params.telegramFileName
-	});
-}
-async function resolveStickerMedia(params) {
-	const { msg, ctx, maxBytes, token, transport } = params;
-	if (!msg.sticker) return;
-	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 resolveTelegramFileWithRetry(ctx);
-		if (!file?.file_path) {
-			logVerbose("telegram: getFile returned no file_path for sticker");
-			return null;
-		}
-		const saved = await downloadAndSaveTelegramFile({
-			filePath: file.file_path,
-			token,
-			transport,
-			maxBytes,
-			apiRoot: params.apiRoot,
-			trustedLocalFileRoots: params.trustedLocalFileRoots,
-			dangerouslyAllowPrivateNetwork: params.dangerouslyAllowPrivateNetwork
-		});
-		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;
-	}
-}
-async function resolveMedia(params) {
-	const { ctx, maxBytes, token, transport, apiRoot, trustedLocalFileRoots, dangerouslyAllowPrivateNetwork } = params;
-	const msg = ctx.message;
-	const stickerResolved = await resolveStickerMedia({
-		msg,
-		ctx,
-		maxBytes,
-		token,
-		transport,
-		apiRoot,
-		trustedLocalFileRoots,
-		dangerouslyAllowPrivateNetwork
-	});
-	if (stickerResolved !== void 0) return stickerResolved;
-	const metadata = resolveMediaMetadata(msg);
-	if (!metadata.fileRef?.file_id) return null;
-	const file = await resolveTelegramFileWithRetry(ctx);
-	if (!file) return null;
-	if (!file.file_path) throw new Error("Telegram getFile returned no file_path");
-	const saved = await downloadAndSaveTelegramFile({
-		filePath: file.file_path,
-		token,
-		transport,
-		maxBytes,
-		telegramFileName: metadata.fileName,
-		mimeType: metadata.mimeType,
-		apiRoot,
-		trustedLocalFileRoots,
-		dangerouslyAllowPrivateNetwork
-	});
-	const placeholder = resolveTelegramMediaPlaceholder(msg) ?? "<media:document>";
-	return {
-		path: saved.path,
-		contentType: saved.contentType,
-		placeholder
-	};
-}
-//#endregion
-export { emitTelegramMessageSentHooks as i, deliverReplies as n, emitInternalMessageSentHook as r, resolveMedia as t };