@desplega.ai/agent-swarm 1.173.0 → 2.1.0

package/dist/index-52j1aja4.js

@@ -0,0 +1,3465 @@
+import {
+  AdapterRateLimitError,
+  AuthenticationError,
+  NetworkError,
+  PermissionError,
+  ResourceNotFoundError,
+  ValidationError,
+  cardToFallbackText,
+  extractCard,
+  extractFiles,
+  extractPostableAttachments
+} from "./cli-9traj3dn.js";
+import {
+  BaseFormatConverter,
+  ConsoleLogger,
+  Message,
+  NotImplementedError,
+  StreamingMarkdownRenderer,
+  convertEmojiPlaceholders,
+  defaultEmojiResolver,
+  getEmoji,
+  isTableNode,
+  markdownToPlainText,
+  parseMarkdown,
+  stringifyMarkdown,
+  tableToAscii,
+  toPlainText,
+  walkAst
+} from "./cli-2m1ktfzz.js";
+import"./cli-kceah1eh.js";
+import"./cli-f527ce74.js";
+import"./cli-bc05qbss.js";
+
+// node_modules/@chat-adapter/telegram/dist/index.js
+import { createHash, timingSafeEqual } from "crypto";
+var CALLBACK_DATA_PREFIX = "chat:";
+var TELEGRAM_CALLBACK_DATA_LIMIT_BYTES = 64;
+function convertLabel(label) {
+  return convertEmojiPlaceholders(label, "gchat");
+}
+function toInlineKeyboardRow(actions) {
+  const row = [];
+  for (const action of actions.children) {
+    if (action.type === "button") {
+      row.push({
+        text: convertLabel(action.label),
+        callback_data: encodeTelegramCallbackData(action.id, action.value)
+      });
+      continue;
+    }
+    if (action.type === "link-button") {
+      row.push({
+        text: convertLabel(action.label),
+        url: action.url
+      });
+    }
+  }
+  return row;
+}
+function collectInlineKeyboardRows(children, rows) {
+  for (const child of children) {
+    if (child.type === "actions") {
+      const row = toInlineKeyboardRow(child);
+      if (row.length > 0) {
+        rows.push(row);
+      }
+      continue;
+    }
+    if (child.type === "section") {
+      collectInlineKeyboardRows(child.children, rows);
+    }
+  }
+}
+function cardToTelegramInlineKeyboard(card) {
+  const rows = [];
+  collectInlineKeyboardRows(card.children, rows);
+  if (rows.length === 0) {
+    return;
+  }
+  return {
+    inline_keyboard: rows
+  };
+}
+function emptyTelegramInlineKeyboard() {
+  return { inline_keyboard: [] };
+}
+function encodeTelegramCallbackData(actionId, value) {
+  const payload = { a: actionId };
+  if (typeof value === "string") {
+    payload.v = value;
+  }
+  const callbackData = `${CALLBACK_DATA_PREFIX}${JSON.stringify(payload)}`;
+  if (Buffer.byteLength(callbackData, "utf8") > TELEGRAM_CALLBACK_DATA_LIMIT_BYTES) {
+    throw new ValidationError("telegram", `Callback payload too large for Telegram (max ${TELEGRAM_CALLBACK_DATA_LIMIT_BYTES} bytes).`);
+  }
+  return callbackData;
+}
+function decodeTelegramCallbackData(data) {
+  if (!data) {
+    return { actionId: "telegram_callback", value: undefined };
+  }
+  if (!data.startsWith(CALLBACK_DATA_PREFIX)) {
+    return { actionId: data, value: data };
+  }
+  try {
+    const decoded = JSON.parse(data.slice(CALLBACK_DATA_PREFIX.length));
+    if (typeof decoded.a === "string" && decoded.a) {
+      return {
+        actionId: decoded.a,
+        value: typeof decoded.v === "string" ? decoded.v : undefined
+      };
+    }
+  } catch {}
+  return { actionId: data, value: data };
+}
+var MARKDOWNV2_SPECIAL_CHARS = /([_*[\]()~`>#+\-=|{}.!\\])/g;
+var CODE_BLOCK_SPECIAL_CHARS = /([`\\])/g;
+var LINK_URL_SPECIAL_CHARS = /([)\\])/g;
+function toBotApiParseMode(mode) {
+  return mode === "MarkdownV2" ? "MarkdownV2" : undefined;
+}
+var TELEGRAM_MESSAGE_LIMIT = 4096;
+var TELEGRAM_CAPTION_LIMIT = 1024;
+var MARKDOWN_V2_ENTITY_MARKERS = ["*", "_", "__", "~", "`"];
+var MARKDOWN_V2_ELLIPSIS = "\\.\\.\\.";
+var PLAIN_ELLIPSIS = "...";
+function escapeMarkdownV2(text2) {
+  return text2.replace(MARKDOWNV2_SPECIAL_CHARS, "\\$1");
+}
+function scanDelimiters(text2) {
+  const markers = {
+    "*": [],
+    _: [],
+    __: [],
+    "~": [],
+    "`": []
+  };
+  const openBrackets = [];
+  let closeBrackets = 0;
+  let inFence = false;
+  let inInline = false;
+  let inLinkUrl = false;
+  let backslashes = 0;
+  const lastIndex = text2.length - 1;
+  for (let i = 0;i < text2.length; i++) {
+    const ch = text2[i];
+    if (ch === "\\") {
+      backslashes++;
+      continue;
+    }
+    const escaped = backslashes % 2 === 1;
+    backslashes = 0;
+    if (escaped) {
+      continue;
+    }
+    if (inLinkUrl) {
+      if (ch === ")") {
+        inLinkUrl = false;
+        closeBrackets++;
+      }
+      continue;
+    }
+    if (ch === "`") {
+      if (!inInline && text2.startsWith("```", i)) {
+        markers["`"].push(i);
+        inFence = !inFence;
+        i += 2;
+        continue;
+      }
+      if (inFence) {
+        continue;
+      }
+      markers["`"].push(i);
+      if (!inInline && i + 2 === text2.length && text2[i + 1] === "`") {
+        i += 1;
+      }
+      inInline = !inInline;
+      continue;
+    }
+    if (inFence || inInline) {
+      continue;
+    }
+    if (ch === "[") {
+      openBrackets.push(i);
+      continue;
+    }
+    if (ch === "]") {
+      if (text2[i + 1] === "(") {
+        inLinkUrl = true;
+        i += 1;
+      } else if (i < lastIndex) {
+        closeBrackets++;
+      }
+      continue;
+    }
+    if (ch === "_") {
+      if (text2[i + 1] === "_") {
+        markers.__.push(i);
+        i += 1;
+      } else {
+        markers._.push(i);
+      }
+      continue;
+    }
+    if (ch === "*" || ch === "~") {
+      markers[ch].push(i);
+    }
+  }
+  return { markers, openBrackets, closeBrackets };
+}
+function endsWithOrphanBackslash(text2) {
+  let trailing = 0;
+  for (let i = text2.length - 1;i >= 0 && text2[i] === "\\"; i--) {
+    trailing++;
+  }
+  return trailing % 2 === 1;
+}
+function trimToMarkdownV2SafeBoundary(text2) {
+  let current = text2;
+  const maxIterations = current.length + 1;
+  for (let i = 0;i < maxIterations; i++) {
+    if (endsWithOrphanBackslash(current)) {
+      current = current.slice(0, -1);
+      continue;
+    }
+    const scan = scanDelimiters(current);
+    let cut = current.length;
+    for (const marker of MARKDOWN_V2_ENTITY_MARKERS) {
+      const positions = scan.markers[marker];
+      if (positions.length % 2 === 1) {
+        cut = Math.min(cut, positions.at(-1) ?? cut);
+      }
+    }
+    if (scan.openBrackets.length > scan.closeBrackets) {
+      cut = Math.min(cut, scan.openBrackets.at(-1) ?? cut);
+    }
+    if (cut >= current.length) {
+      return current;
+    }
+    current = current.slice(0, cut);
+  }
+  return current;
+}
+function truncateForTelegram(text2, limit, parseMode) {
+  if (text2.length <= limit) {
+    return text2;
+  }
+  const isMarkdownV2 = parseMode === "MarkdownV2";
+  const ellipsis = isMarkdownV2 ? MARKDOWN_V2_ELLIPSIS : PLAIN_ELLIPSIS;
+  let slice = text2.slice(0, limit - ellipsis.length);
+  if (isMarkdownV2) {
+    slice = trimToMarkdownV2SafeBoundary(slice);
+  }
+  return `${slice}${ellipsis}`;
+}
+function escapeCodeBlock(text2) {
+  return text2.replace(CODE_BLOCK_SPECIAL_CHARS, "\\$1");
+}
+function escapeLinkUrl(text2) {
+  return text2.replace(LINK_URL_SPECIAL_CHARS, "\\$1");
+}
+function renderMarkdownV2(node) {
+  switch (node.type) {
+    case "root":
+      return node.children.map(renderMarkdownV2).join(`
+
+`);
+    case "paragraph":
+      return node.children.map(renderMarkdownV2).join("");
+    case "text":
+      return escapeMarkdownV2(node.value);
+    case "strong":
+      return `*${node.children.map(renderMarkdownV2).join("")}*`;
+    case "emphasis":
+      return `_${node.children.map(renderMarkdownV2).join("")}_`;
+    case "delete":
+      return `~${node.children.map(renderMarkdownV2).join("")}~`;
+    case "inlineCode":
+      return `\`${escapeCodeBlock(node.value)}\``;
+    case "code": {
+      const lang = node.lang ?? "";
+      const val = escapeCodeBlock(node.value);
+      return `\`\`\`${lang}
+${val}
+\`\`\``;
+    }
+    case "link": {
+      const linkText = node.children.map(renderMarkdownV2).join("");
+      const url = escapeLinkUrl(node.url);
+      return `[${linkText}](${url})`;
+    }
+    case "blockquote": {
+      const inner = node.children.map(renderMarkdownV2).join(`
+`);
+      return inner.split(`
+`).map((line) => `>${line}`).join(`
+`);
+    }
+    case "list":
+      return node.children.map((item2, i) => {
+        const content = item2.children.map(renderMarkdownV2).join(`
+`);
+        if (node.ordered) {
+          return `${escapeMarkdownV2(`${i + 1}.`)} ${content}`;
+        }
+        return `\\- ${content}`;
+      }).join(`
+`);
+    case "listItem":
+      return node.children.map(renderMarkdownV2).join(`
+`);
+    case "heading": {
+      const text2 = node.children.map(renderMarkdownV2).join("");
+      return `*${text2}*`;
+    }
+    case "thematicBreak":
+      return escapeMarkdownV2("———");
+    case "break":
+      return `
+`;
+    case "image": {
+      const alt = escapeMarkdownV2(node.alt ?? "");
+      const url = escapeLinkUrl(node.url);
+      return `[${alt}](${url})`;
+    }
+    case "html":
+      return escapeMarkdownV2(node.value);
+    case "linkReference":
+    case "imageReference":
+      if ("children" in node && node.children.length > 0) {
+        return node.children.map(renderMarkdownV2).join("");
+      }
+      return escapeMarkdownV2(node.label ?? node.identifier);
+    case "definition":
+      return "";
+    case "footnoteDefinition":
+      return "";
+    case "footnoteReference":
+      return escapeMarkdownV2(`[^${node.label ?? node.identifier}]`);
+    case "yaml":
+      return "";
+    case "table":
+    case "tableRow":
+    case "tableCell":
+      throw new Error(`Telegram MarkdownV2 renderer received a ${node.type} node; fromAst should have preprocessed it into a code block.`);
+    default: {
+      throw new Error(`Unhandled case: ${node}`);
+    }
+  }
+}
+var TelegramFormatConverter = class extends BaseFormatConverter {
+  fromAst(ast) {
+    const transformed = walkAst(structuredClone(ast), (node) => {
+      if (isTableNode(node)) {
+        return {
+          type: "code",
+          value: tableToAscii(node),
+          lang: undefined
+        };
+      }
+      return node;
+    });
+    return renderMarkdownV2(transformed).trim();
+  }
+  toAst(text2) {
+    return parseMarkdown(text2);
+  }
+  renderPostable(message) {
+    if (typeof message === "string") {
+      return message;
+    }
+    if ("raw" in message) {
+      return message.raw;
+    }
+    if ("markdown" in message) {
+      return this.fromMarkdown(message.markdown);
+    }
+    if ("ast" in message) {
+      return this.fromAst(message.ast);
+    }
+    return super.renderPostable(message);
+  }
+};
+var TELEGRAM_RICH_MESSAGE_LIMIT = 32768;
+var MARKDOWN_PUNCTUATION = /[!-/:-@[-`{-~]/g;
+var LINE_BREAKS = /[\r\n]/g;
+var BACKTICKS = /`+/g;
+function truncateRichMarkdown(markdown) {
+  const characters = Array.from(markdown);
+  if (characters.length <= TELEGRAM_RICH_MESSAGE_LIMIT) {
+    return markdown;
+  }
+  let end = TELEGRAM_RICH_MESSAGE_LIMIT - 3;
+  while (end > 0) {
+    const renderer = new StreamingMarkdownRenderer;
+    renderer.push(characters.slice(0, end).join(""));
+    const rendered = `${renderer.finish()}...`;
+    if (Array.from(rendered).length <= TELEGRAM_RICH_MESSAGE_LIMIT) {
+      return rendered;
+    }
+    end -= Array.from(rendered).length - TELEGRAM_RICH_MESSAGE_LIMIT;
+  }
+  return "...";
+}
+function escapeText(value) {
+  return value.replace(MARKDOWN_PUNCTUATION, "\\$&");
+}
+function inlineCode(value) {
+  if (!value) {
+    return "";
+  }
+  const runs = value.match(BACKTICKS) ?? [];
+  const size = Math.max(1, ...runs.map((run) => run.length + 1));
+  const marker = "`".repeat(size);
+  const hasBoundarySpace = value.startsWith(" ") && value.endsWith(" ") && value.trim().length > 0;
+  const padding = value.startsWith("`") || value.endsWith("`") || hasBoundarySpace ? " " : "";
+  return `${marker}${padding}${value}${padding}${marker}`;
+}
+function codeBlock(value, language) {
+  const runs = value.match(BACKTICKS) ?? [];
+  const size = Math.max(3, ...runs.map((run) => run.length + 1));
+  const marker = "`".repeat(size);
+  const info = language?.replace(LINE_BREAKS, " ").replaceAll("`", "") ?? "";
+  return `${marker}${info}
+${value}
+${marker}`;
+}
+function linkDestination(value) {
+  return `<${value.replaceAll("\\", "%5C").replaceAll("<", "%3C").replaceAll(">", "%3E").replaceAll("\r", "%0D").replaceAll(`
+`, "%0A")}>`;
+}
+function text(markdown) {
+  if (typeof markdown === "string") {
+    return escapeText(markdown);
+  }
+  if (Array.isArray(markdown)) {
+    return markdown.map(text).join("");
+  }
+  switch (markdown.type) {
+    case "bold":
+      return `**${text(markdown.text)}**`;
+    case "italic":
+      return `_${text(markdown.text)}_`;
+    case "underline":
+      return `<u>${text(markdown.text)}</u>`;
+    case "strikethrough":
+      return `~~${text(markdown.text)}~~`;
+    case "spoiler":
+      return `||${text(markdown.text)}||`;
+    case "subscript":
+      return `<sub>${text(markdown.text)}</sub>`;
+    case "superscript":
+      return `<sup>${text(markdown.text)}</sup>`;
+    case "marked":
+      return `==${text(markdown.text)}==`;
+    case "code":
+      return inlineCode(plain(markdown.text));
+    case "date_time":
+    case "text_mention":
+      return text(markdown.text);
+    case "bank_card_number":
+    case "bot_command":
+    case "cashtag":
+    case "hashtag":
+    case "mention":
+      return text(markdown.text);
+    case "custom_emoji":
+      return markdown.alternative_text;
+    case "mathematical_expression":
+      return `$${markdown.expression}$`;
+    case "url":
+      return `[${text(markdown.text)}](${linkDestination(markdown.url)})`;
+    case "email_address":
+      return `[${text(markdown.text)}](${linkDestination(`mailto:${markdown.email_address}`)})`;
+    case "phone_number":
+      return `[${text(markdown.text)}](${linkDestination(`tel:${markdown.phone_number}`)})`;
+    case "anchor":
+      return "";
+    case "anchor_link":
+    case "reference":
+    case "reference_link":
+      return text(markdown.text);
+    default:
+      return "";
+  }
+}
+function plain(markdown) {
+  if (typeof markdown === "string") {
+    return markdown;
+  }
+  if (Array.isArray(markdown)) {
+    return markdown.map(plain).join("");
+  }
+  switch (markdown.type) {
+    case "bold":
+    case "italic":
+    case "underline":
+    case "strikethrough":
+    case "spoiler":
+    case "subscript":
+    case "superscript":
+    case "marked":
+    case "code":
+    case "date_time":
+    case "text_mention":
+    case "url":
+    case "email_address":
+    case "phone_number":
+    case "bank_card_number":
+    case "mention":
+    case "hashtag":
+    case "cashtag":
+    case "bot_command":
+    case "anchor_link":
+    case "reference":
+    case "reference_link":
+      return plain(markdown.text);
+    case "custom_emoji":
+      return markdown.alternative_text;
+    case "mathematical_expression":
+      return markdown.expression;
+    case "anchor":
+      return "";
+    default:
+      return "";
+  }
+}
+function caption(value) {
+  if (!value) {
+    return "";
+  }
+  const credit = value.credit ? `
+${text(value.credit)}` : "";
+  return `${text(value.text)}${credit}`;
+}
+function plainCaption(value) {
+  if (!value) {
+    return "";
+  }
+  const credit = value.credit ? `
+${plain(value.credit)}` : "";
+  return `${plain(value.text)}${credit}`;
+}
+function cell(value) {
+  return value.text ? text(value.text) : "";
+}
+function item(value) {
+  let checked = "";
+  if (value.has_checkbox) {
+    checked = value.is_checked ? "[x] " : "[ ] ";
+  }
+  const content = value.blocks.map(block).join(`
+
+`).replaceAll(`
+`, `
+  `);
+  return `${value.label} ${checked}${content}`.trimEnd();
+}
+function plainItem(value) {
+  let checked = "";
+  if (value.has_checkbox) {
+    checked = value.is_checked ? "[x] " : "[ ] ";
+  }
+  const content = value.blocks.map(plainBlock).filter(Boolean).join(`
+`).replaceAll(`
+`, `
+  `);
+  return `${value.label} ${checked}${content}`.trimEnd();
+}
+function table(value) {
+  const rows = value.cells.map((row) => `| ${row.map(cell).join(" | ")} |`);
+  if (rows.length === 0) {
+    return value.caption ? text(value.caption) : "";
+  }
+  const columns = Math.max(...value.cells.map((row) => row.length));
+  const separator = `| ${Array.from({ length: columns }, () => "---").join(" | ")} |`;
+  const content = [rows[0], separator, ...rows.slice(1)].join(`
+`);
+  return value.caption ? `${text(value.caption)}
+
+${content}` : content;
+}
+function quote(value) {
+  return value.split(`
+`).map((line) => `> ${line}`).join(`
+`);
+}
+function block(value) {
+  switch (value.type) {
+    case "paragraph":
+    case "footer":
+    case "thinking":
+      return text(value.text);
+    case "heading":
+      return `${"#".repeat(Math.min(6, Math.max(1, value.size)))} ${text(value.text)}`;
+    case "pre":
+      return codeBlock(plain(value.text), value.language);
+    case "divider":
+      return "---";
+    case "mathematical_expression":
+      return `$$${value.expression}$$`;
+    case "anchor":
+      return "";
+    case "list":
+      return value.items.map(item).join(`
+`);
+    case "blockquote": {
+      const content = value.blocks.map(block).join(`
+
+`);
+      const credit = value.credit ? `
+
+${text(value.credit)}` : "";
+      return quote(`${content}${credit}`);
+    }
+    case "pullquote": {
+      const credit = value.credit ? `
+
+${text(value.credit)}` : "";
+      return quote(`${text(value.text)}${credit}`);
+    }
+    case "collage":
+    case "slideshow": {
+      const content = value.blocks.map(block).filter(Boolean).join(`
+
+`);
+      const description = caption(value.caption);
+      return [content, description].filter(Boolean).join(`
+
+`);
+    }
+    case "table":
+      return table(value);
+    case "details":
+      return `${text(value.summary)}
+
+${value.blocks.map(block).join(`
+
+`)}`;
+    case "map":
+      return caption(value.caption);
+    case "animation":
+    case "audio":
+    case "photo":
+    case "video":
+    case "voice_note":
+      return caption(value.caption);
+    default:
+      return "";
+  }
+}
+function plainBlock(value) {
+  switch (value.type) {
+    case "paragraph":
+    case "footer":
+    case "thinking":
+    case "heading":
+    case "pre":
+      return plain(value.text);
+    case "divider":
+    case "anchor":
+      return "";
+    case "mathematical_expression":
+      return value.expression;
+    case "list":
+      return value.items.map(plainItem).join(`
+`);
+    case "blockquote": {
+      const content = value.blocks.map(plainBlock).filter(Boolean).join(`
+
+`);
+      const credit = value.credit ? `
+
+${plain(value.credit)}` : "";
+      return `${content}${credit}`;
+    }
+    case "pullquote": {
+      const credit = value.credit ? `
+
+${plain(value.credit)}` : "";
+      return `${plain(value.text)}${credit}`;
+    }
+    case "collage":
+    case "slideshow": {
+      const content = value.blocks.map(plainBlock).filter(Boolean).join(`
+
+`);
+      const description = plainCaption(value.caption);
+      return [content, description].filter(Boolean).join(`
+
+`);
+    }
+    case "table": {
+      const rows = value.cells.map((row) => row.map((entry) => entry.text ? plain(entry.text) : "").join("\t"));
+      const content = rows.join(`
+`);
+      return value.caption ? `${plain(value.caption)}
+
+${content}` : content;
+    }
+    case "details":
+      return `${plain(value.summary)}
+
+${value.blocks.map(plainBlock).filter(Boolean).join(`
+
+`)}`;
+    case "map":
+      return plainCaption(value.caption);
+    case "animation":
+    case "audio":
+    case "photo":
+    case "video":
+    case "voice_note":
+      return plainCaption(value.caption);
+    default:
+      return "";
+  }
+}
+function media(blocks, result) {
+  for (const value of blocks) {
+    switch (value.type) {
+      case "list":
+        for (const entry of value.items) {
+          media(entry.blocks, result);
+        }
+        break;
+      case "blockquote":
+      case "collage":
+      case "slideshow":
+      case "details":
+        media(value.blocks, result);
+        break;
+      case "animation":
+        result.push({
+          file: value.animation,
+          height: value.animation.height,
+          mimeType: value.animation.mime_type,
+          name: value.animation.file_name,
+          type: value.animation.mime_type?.startsWith("image/") ? "image" : "video",
+          width: value.animation.width
+        });
+        break;
+      case "audio":
+        result.push({
+          file: value.audio,
+          mimeType: value.audio.mime_type,
+          name: value.audio.file_name,
+          type: "audio"
+        });
+        break;
+      case "photo": {
+        const photo = value.photo.at(-1);
+        if (photo) {
+          result.push({
+            file: photo,
+            height: photo.height,
+            mimeType: "image/jpeg",
+            type: "image",
+            width: photo.width
+          });
+        }
+        break;
+      }
+      case "video":
+        result.push({
+          file: value.video,
+          height: value.video.height,
+          mimeType: value.video.mime_type,
+          name: value.video.file_name,
+          type: "video",
+          width: value.video.width
+        });
+        break;
+      case "voice_note":
+        result.push({
+          file: value.voice_note,
+          mimeType: value.voice_note.mime_type,
+          type: "audio"
+        });
+        break;
+      default:
+        break;
+    }
+  }
+}
+function richMessageToMarkdown(message) {
+  return message.blocks.map(block).filter(Boolean).join(`
+
+`).trim();
+}
+function richMessageToText(message) {
+  return message.blocks.map(plainBlock).filter(Boolean).join(`
+
+`).trim();
+}
+function richMessageMedia(message) {
+  const result = [];
+  media(message.blocks, result);
+  return result;
+}
+var TELEGRAM_API_BASE = "https://api.telegram.org";
+var TELEGRAM_FILE_LIMIT = 25 * 1024 * 1024;
+var TELEGRAM_FILE_TIMEOUT_MS = 30000;
+async function readTelegramFile(response, fileId) {
+  const declared = Number(response.headers.get("content-length"));
+  if (Number.isFinite(declared) && declared > TELEGRAM_FILE_LIMIT) {
+    await response.body?.cancel();
+    throw new NetworkError("telegram", `Telegram file ${fileId} exceeds the download limit`);
+  }
+  const reader = response.body?.getReader();
+  if (!reader) {
+    return await response.arrayBuffer();
+  }
+  const chunks = [];
+  let size = 0;
+  for (;; ) {
+    const { done, value } = await reader.read();
+    if (done) {
+      break;
+    }
+    size += value.length;
+    if (size > TELEGRAM_FILE_LIMIT) {
+      await reader.cancel();
+      throw new NetworkError("telegram", `Telegram file ${fileId} exceeds the download limit`);
+    }
+    chunks.push(value);
+  }
+  const data = new Uint8Array(size);
+  let offset = 0;
+  for (const chunk of chunks) {
+    data.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return data.buffer;
+}
+var TELEGRAM_SECRET_TOKEN_HEADER = "x-telegram-bot-api-secret-token";
+var TELEGRAM_WEBHOOK_VERIFICATION_ERROR = "secretToken is required in webhook mode. Set TELEGRAM_WEBHOOK_SECRET_TOKEN or provide secretToken. To accept unverified webhooks, set allowUnverifiedWebhooks: true or TELEGRAM_ALLOW_UNVERIFIED_WEBHOOKS=true.";
+var MESSAGE_ID_PATTERN = /^([^:]+):(\d+)$/;
+var BARE_MESSAGE_ID_PATTERN = /^\d+$/;
+var trimTrailingSlashes = (url) => {
+  let end = url.length;
+  while (end > 0 && url[end - 1] === "/") {
+    end--;
+  }
+  return url.slice(0, end);
+};
+var MESSAGE_SEQUENCE_PATTERN = /:(\d+)$/;
+var ATTACHMENT_UPLOADS = {
+  audio: { field: "audio", method: "sendAudio" },
+  file: { field: "document", method: "sendDocument" },
+  image: { field: "photo", method: "sendPhoto" },
+  video: { field: "video", method: "sendVideo" }
+};
+var ATTACHMENT_MEDIA_GROUP_TYPES = {
+  audio: "audio",
+  file: "document",
+  image: "photo",
+  video: "video"
+};
+var LEADING_AT_PATTERN = /^@+/;
+var EMOJI_PLACEHOLDER_PATTERN = /^\{\{emoji:([a-z0-9_]+)\}\}$/i;
+var EMOJI_NAME_PATTERN = /^[a-z0-9_+-]+$/i;
+var TELEGRAM_DEFAULT_POLLING_TIMEOUT_SECONDS = 30;
+var TELEGRAM_DEFAULT_POLLING_LIMIT = 100;
+var TELEGRAM_DEFAULT_POLLING_RETRY_DELAY_MS = 1000;
+var TELEGRAM_DEFAULT_STREAM_UPDATE_INTERVAL_MS = 250;
+var TELEGRAM_DEFAULT_PRIVATE_STREAMING_EDIT_INTERVAL_MS = 1100;
+var TELEGRAM_DEFAULT_NON_PRIVATE_STREAMING_EDIT_INTERVAL_MS = 3100;
+var TELEGRAM_STREAM_FINAL_EDIT_RETRY_CAP_MS = 5000;
+var TELEGRAM_STREAM_PLACEHOLDER_TEXT = "...";
+var TELEGRAM_INCOMING_MEDIA_GROUP_BUFFER_TTL_MS = 30000;
+var TELEGRAM_INCOMING_MEDIA_GROUP_LOCK_TTL_MS = 5000;
+var TELEGRAM_INCOMING_MEDIA_GROUP_RETRY_MS = 50;
+var TELEGRAM_INCOMING_MEDIA_GROUP_SETTLE_MS = 1000;
+var TELEGRAM_WEBHOOK_UPDATE_TTL_MS = 24 * 60 * 60 * 1000;
+var TELEGRAM_MEDIA_GROUP_MIN = 2;
+var TELEGRAM_MEDIA_GROUP_MAX = 10;
+var TELEGRAM_MARKDOWN_PARSE_ERROR_PATTERN = /can't parse (?:caption )?entities/i;
+var TELEGRAM_MAX_POLLING_LIMIT = 100;
+var TELEGRAM_MIN_POLLING_LIMIT = 1;
+var TELEGRAM_MIN_POLLING_TIMEOUT_SECONDS = 0;
+var TELEGRAM_MAX_POLLING_TIMEOUT_SECONDS = 300;
+var TELEGRAM_BUSINESS_ALLOWED_UPDATES = [
+  "business_connection",
+  "business_message",
+  "edited_business_message"
+];
+var TELEGRAM_DEFAULT_ALLOWED_UPDATES = [
+  "message",
+  "edited_message",
+  "channel_post",
+  "edited_channel_post",
+  "callback_query"
+];
+var TELEGRAM_BUSINESS_CONNECTION_TTL_MS = 60 * 60 * 1000;
+function normalizeBotTokenProvider(botToken) {
+  if (typeof botToken === "function") {
+    return async () => await botToken();
+  }
+  return () => Promise.resolve(botToken);
+}
+var escapeMarkdownInEntity = (text2) => text2.replace(/([[\]()\\])/g, "\\$1");
+function applyTelegramEntities(text2, entities) {
+  if (entities.length === 0) {
+    return text2;
+  }
+  const sorted = [...entities].sort((a, b) => {
+    const offsetDiff = b.offset - a.offset;
+    if (offsetDiff !== 0) {
+      return offsetDiff;
+    }
+    return a.length - b.length;
+  });
+  let result = text2;
+  for (const entity of sorted) {
+    const start = entity.offset;
+    const end = entity.offset + entity.length;
+    const entityText = result.slice(start, end);
+    let replacement;
+    switch (entity.type) {
+      case "text_link": {
+        if (entity.url) {
+          replacement = `[${escapeMarkdownInEntity(entityText)}](${entity.url})`;
+        }
+        break;
+      }
+      case "bold": {
+        replacement = `**${entityText}**`;
+        break;
+      }
+      case "italic": {
+        replacement = `*${entityText}*`;
+        break;
+      }
+      case "code": {
+        replacement = `\`${entityText}\``;
+        break;
+      }
+      case "pre": {
+        const lang = entity.language ?? "";
+        replacement = `\`\`\`${lang}
+${entityText}
+\`\`\``;
+        break;
+      }
+      case "strikethrough": {
+        replacement = `~~${entityText}~~`;
+        break;
+      }
+      default:
+        break;
+    }
+    if (replacement !== undefined) {
+      result = result.slice(0, start) + replacement + result.slice(end);
+    }
+  }
+  return result;
+}
+function describeNonFileContent(raw) {
+  if (raw.venue) {
+    return `\uD83D\uDCCD ${raw.venue.title}, ${raw.venue.address}`;
+  }
+  if (raw.location) {
+    return `\uD83D\uDCCD ${raw.location.latitude}, ${raw.location.longitude}`;
+  }
+  if (raw.contact) {
+    const name = [raw.contact.first_name, raw.contact.last_name].filter(Boolean).join(" ");
+    return `\uD83D\uDC64 ${name} ${raw.contact.phone_number}`.trim();
+  }
+  if (raw.poll) {
+    return `\uD83D\uDCCA ${raw.poll.question}`;
+  }
+  if (raw.dice) {
+    return `${raw.dice.emoji} ${raw.dice.value}`;
+  }
+  if (raw.game) {
+    return `\uD83C\uDFAE ${raw.game.title}`;
+  }
+  if (raw.invoice) {
+    const amount = formatInvoiceAmount(raw.invoice.total_amount, raw.invoice.currency);
+    return `\uD83E\uDDFE ${raw.invoice.title} — ${amount} ${raw.invoice.currency}`;
+  }
+  if (raw.story) {
+    return "\uD83D\uDCD6 Story";
+  }
+  return;
+}
+var ZERO_EXPONENT_CURRENCIES = /* @__PURE__ */ new Set([
+  "CLP",
+  "ISK",
+  "JPY",
+  "KRW",
+  "PYG",
+  "UGX",
+  "VND",
+  "XTR"
+]);
+var THREE_EXPONENT_CURRENCIES = /* @__PURE__ */ new Set(["BHD", "IQD", "JOD"]);
+function formatInvoiceAmount(totalAmount, currency) {
+  let exponent = 2;
+  if (ZERO_EXPONENT_CURRENCIES.has(currency)) {
+    exponent = 0;
+  } else if (THREE_EXPONENT_CURRENCIES.has(currency)) {
+    exponent = 3;
+  }
+  return (totalAmount / 10 ** exponent).toFixed(exponent);
+}
+function stickerAttachmentFormat(sticker) {
+  if (sticker.is_video) {
+    return { type: "video", mimeType: "video/webm" };
+  }
+  if (sticker.is_animated) {
+    return { type: "file", mimeType: "application/x-tgsticker" };
+  }
+  return { type: "image", mimeType: "image/webp" };
+}
+var TelegramAdapter = class {
+  name = "telegram";
+  lockScope = "channel";
+  persistThreadHistory = true;
+  allowedUserIds;
+  allowUnverifiedWebhooks;
+  botTokenProvider;
+  staticBotToken;
+  apiBaseUrl;
+  secretToken;
+  mentionOnReply;
+  botIdentityPromise = null;
+  webhookScope;
+  warnedNoVerification = false;
+  logger;
+  formatConverter = new TelegramFormatConverter;
+  messageCache = /* @__PURE__ */ new Map;
+  chat = null;
+  _botUserId;
+  _userName;
+  _mentionRegexUsername;
+  _mentionRegex;
+  hasExplicitUserName;
+  mode;
+  nativeStreaming;
+  streamingEditIntervalMs;
+  longPolling;
+  businessMode;
+  _runtimeMode = "webhook";
+  pollingAbortController = null;
+  pollingTask = null;
+  pollingActive = false;
+  nextDraftId = Math.max(1, Date.now() % 2147483647);
+  richMessagesAvailable = true;
+  get botUserId() {
+    return this._botUserId;
+  }
+  get userName() {
+    return this._userName;
+  }
+  get isPolling() {
+    return this.pollingActive;
+  }
+  get runtimeMode() {
+    return this._runtimeMode;
+  }
+  constructor(config = {}) {
+    const botToken = config.botToken ?? process.env.TELEGRAM_BOT_TOKEN;
+    if (!botToken) {
+      throw new ValidationError("telegram", "botToken is required. Set TELEGRAM_BOT_TOKEN or provide it in config.");
+    }
+    this.botTokenProvider = normalizeBotTokenProvider(botToken);
+    this.staticBotToken = typeof botToken === "string" ? botToken : undefined;
+    this.apiBaseUrl = trimTrailingSlashes(config.apiUrl ?? config.apiBaseUrl ?? process.env.TELEGRAM_API_BASE_URL ?? TELEGRAM_API_BASE);
+    this.secretToken = config.secretToken ?? process.env.TELEGRAM_WEBHOOK_SECRET_TOKEN;
+    this.allowUnverifiedWebhooks = config.allowUnverifiedWebhooks ?? process.env.TELEGRAM_ALLOW_UNVERIFIED_WEBHOOKS === "true";
+    this.mentionOnReply = config.mentionOnReply ?? process.env.TELEGRAM_MENTION_ON_REPLY === "true";
+    const allowedUserIds = config.allowedUserIds ?? process.env.TELEGRAM_ALLOWED_USER_IDS?.split(",");
+    const normalizedAllowedUserIds = allowedUserIds?.map((id) => String(id).trim()).filter(Boolean);
+    this.allowedUserIds = normalizedAllowedUserIds?.length ? new Set(normalizedAllowedUserIds) : undefined;
+    this.logger = config.logger ?? new ConsoleLogger("info").child("telegram");
+    const userName = config.userName ?? process.env.TELEGRAM_BOT_USERNAME;
+    this._userName = this.normalizeUserName(userName ?? "bot");
+    this.hasExplicitUserName = Boolean(userName);
+    this.mode = config.mode ?? "auto";
+    this.nativeStreaming = config.nativeStreaming ?? false;
+    this.streamingEditIntervalMs = typeof config.streamingEditIntervalMs !== "number" || !Number.isFinite(config.streamingEditIntervalMs) ? undefined : this.clampInteger(config.streamingEditIntervalMs, 0, 0, Number.MAX_SAFE_INTEGER);
+    this.longPolling = config.longPolling;
+    this.businessMode = config.businessMode ?? false;
+    if (!["auto", "webhook", "polling"].includes(this.mode)) {
+      throw new ValidationError("telegram", `Invalid mode: ${this.mode}. Expected "auto", "webhook", or "polling".`);
+    }
+    if (this.mode === "webhook" && !(this.secretToken || this.allowUnverifiedWebhooks)) {
+      throw new ValidationError("telegram", TELEGRAM_WEBHOOK_VERIFICATION_ERROR);
+    }
+  }
+  async resolveBotToken() {
+    const botToken = await this.botTokenProvider();
+    if (!botToken) {
+      throw new AuthenticationError("telegram", "Telegram bot token resolver returned an empty token. Check TELEGRAM_BOT_TOKEN or the Vercel Connect connector.");
+    }
+    return botToken;
+  }
+  async ensureBotIdentity() {
+    if (this.webhookScope) {
+      return;
+    }
+    if (!this.botIdentityPromise) {
+      this.botIdentityPromise = this.telegramFetch("getMe").then((me) => {
+        this._botUserId = String(me.id);
+        this.webhookScope = createHash("sha256").update(this._botUserId).digest("hex");
+        if (!this.hasExplicitUserName && me.username) {
+          this._userName = this.normalizeUserName(me.username);
+        }
+        this.logger.info("Telegram bot identity resolved", {
+          botUserId: this._botUserId,
+          userName: this._userName
+        });
+      }).finally(() => {
+        this.botIdentityPromise = null;
+      });
+    }
+    await this.botIdentityPromise;
+  }
+  async initialize(chat) {
+    this.chat = chat;
+    if (!this.hasExplicitUserName) {
+      const chatUserName = chat.getUserName?.();
+      if (typeof chatUserName === "string" && chatUserName.trim()) {
+        this._userName = this.normalizeUserName(chatUserName);
+      }
+    }
+    try {
+      await this.ensureBotIdentity();
+    } catch (error) {
+      this.logger.warn("Failed to fetch Telegram bot identity", {
+        error: String(error)
+      });
+    }
+    const runtimeMode = await this.resolveRuntimeMode();
+    this._runtimeMode = runtimeMode;
+    if (runtimeMode === "webhook" && !(this.secretToken || this.allowUnverifiedWebhooks)) {
+      throw new ValidationError("telegram", TELEGRAM_WEBHOOK_VERIFICATION_ERROR);
+    }
+    if (runtimeMode === "polling") {
+      const pollingConfig = this.longPolling;
+      if (this.mode === "auto") {
+        await this.startPolling(pollingConfig ? { ...pollingConfig, deleteWebhook: false } : { deleteWebhook: false });
+      } else {
+        await this.startPolling(pollingConfig);
+      }
+    }
+  }
+  async getUser(userId) {
+    try {
+      const chat = await this.telegramFetch("getChat", {
+        chat_id: userId
+      });
+      if (chat.type !== "private") {
+        return null;
+      }
+      const fullName = [chat.first_name, chat.last_name].filter(Boolean).join(" ");
+      return {
+        email: undefined,
+        fullName: fullName || String(chat.id),
+        isBot: false,
+        userId: String(chat.id),
+        userName: chat.username || chat.first_name || String(chat.id)
+      };
+    } catch {
+      return null;
+    }
+  }
+  async handleWebhook(request, options) {
+    if (!(this.secretToken || this.allowUnverifiedWebhooks)) {
+      this.logger.warn("Telegram webhook rejected because verification is not configured");
+      return new Response("Webhook verification required", { status: 401 });
+    }
+    if (this.secretToken) {
+      const headerToken = request.headers.get(TELEGRAM_SECRET_TOKEN_HEADER);
+      let valid = false;
+      try {
+        valid = !!headerToken && timingSafeEqual(Buffer.from(headerToken), Buffer.from(this.secretToken));
+      } catch {}
+      if (!valid) {
+        this.logger.warn("Telegram webhook rejected due to invalid secret token");
+        return new Response("Invalid secret token", { status: 401 });
+      }
+    } else if (!this.warnedNoVerification) {
+      this.warnedNoVerification = true;
+      this.logger.warn("Telegram webhook verification is explicitly disabled");
+    }
+    let update;
+    try {
+      update = await request.json();
+    } catch {
+      return new Response("Invalid JSON", { status: 400 });
+    }
+    if (!this.chat) {
+      this.logger.warn("Chat instance not initialized, ignoring Telegram webhook");
+      return new Response("OK", { status: 200 });
+    }
+    if (Number.isInteger(update.update_id)) {
+      let webhookScope = this.webhookScope;
+      if (!webhookScope) {
+        try {
+          await this.ensureBotIdentity();
+          webhookScope = this.webhookScope;
+        } catch (error) {
+          this.logger.warn("Telegram webhook update could not resolve bot identity", { error: String(error) });
+          return new Response("Service unavailable", { status: 503 });
+        }
+      }
+      if (!webhookScope) {
+        return new Response("Service unavailable", { status: 503 });
+      }
+      try {
+        const claimed = await this.chat.getState().setIfNotExists(`${this.name}:webhook-update:${webhookScope}:${update.update_id}`, true, TELEGRAM_WEBHOOK_UPDATE_TTL_MS);
+        if (!claimed) {
+          this.logger.debug("Ignoring duplicate Telegram webhook update", {
+            updateId: update.update_id
+          });
+          return new Response("OK", { status: 200 });
+        }
+      } catch (error) {
+        this.logger.warn("Failed to claim Telegram webhook update", {
+          error: String(error),
+          updateId: update.update_id
+        });
+        return new Response("Service unavailable", { status: 503 });
+      }
+    }
+    try {
+      this.processUpdate(update, options);
+    } catch (error) {
+      this.logger.warn("Failed to process Telegram webhook update", {
+        error: String(error),
+        updateId: update.update_id
+      });
+    }
+    return new Response("OK", { status: 200 });
+  }
+  async startPolling(config) {
+    if (!this.chat) {
+      throw new ValidationError("telegram", "Cannot start polling before initialize()");
+    }
+    if (this.pollingActive) {
+      this.logger.debug("Telegram polling already active");
+      return;
+    }
+    const resolvedConfig = this.resolvePollingConfig(config);
+    const previousRuntimeMode = this._runtimeMode;
+    this.pollingActive = true;
+    try {
+      if (resolvedConfig.deleteWebhook) {
+        await this.resetWebhook(resolvedConfig.dropPendingUpdates);
+      }
+      this._runtimeMode = "polling";
+    } catch (error) {
+      this.pollingActive = false;
+      this._runtimeMode = previousRuntimeMode;
+      throw error;
+    }
+    this.logger.info("Telegram polling started", {
+      limit: resolvedConfig.limit,
+      timeout: resolvedConfig.timeout,
+      allowedUpdates: resolvedConfig.allowedUpdates
+    });
+    this.pollingTask = this.pollingLoop(resolvedConfig).finally(() => {
+      this.pollingActive = false;
+      this.pollingAbortController = null;
+      this.pollingTask = null;
+    });
+  }
+  async stopPolling() {
+    if (!this.pollingActive) {
+      return;
+    }
+    this.pollingActive = false;
+    this.pollingAbortController?.abort();
+    if (this.pollingTask) {
+      await this.pollingTask;
+    }
+    this.logger.info("Telegram polling stopped");
+  }
+  async disconnect() {
+    await this.stopPolling();
+  }
+  async resetWebhook(dropPendingUpdates = false) {
+    await this.telegramFetch("deleteWebhook", {
+      drop_pending_updates: dropPendingUpdates
+    });
+    this.logger.info("Telegram webhook reset", {
+      dropPendingUpdates
+    });
+  }
+  async resolveRuntimeMode() {
+    if (this.mode === "webhook") {
+      return "webhook";
+    }
+    if (this.mode === "polling") {
+      return "polling";
+    }
+    const webhookInfo = await this.fetchWebhookInfo();
+    if (!webhookInfo) {
+      this.logger.warn("Telegram auto mode could not verify webhook status; keeping webhook mode");
+      return "webhook";
+    }
+    if (typeof webhookInfo.url === "string" && webhookInfo.url.trim()) {
+      this.logger.debug("Telegram auto mode selected webhook mode", {
+        webhookUrl: webhookInfo.url
+      });
+      return "webhook";
+    }
+    if (this.isLikelyServerlessRuntime()) {
+      this.logger.warn("Telegram auto mode detected serverless runtime without webhook URL; keeping webhook mode");
+      return "webhook";
+    }
+    this.logger.info("Telegram auto mode selected polling mode");
+    return "polling";
+  }
+  async fetchWebhookInfo() {
+    try {
+      return await this.telegramFetch("getWebhookInfo");
+    } catch (error) {
+      this.logger.warn("Failed to fetch Telegram webhook info", {
+        error: String(error)
+      });
+      return null;
+    }
+  }
+  isLikelyServerlessRuntime() {
+    if (typeof process === "undefined" || !process.env) {
+      return false;
+    }
+    return Boolean(process.env.VERCEL || process.env.AWS_LAMBDA_FUNCTION_NAME || process.env.AWS_EXECUTION_ENV?.includes("AWS_Lambda") || process.env.FUNCTIONS_WORKER_RUNTIME || process.env.NETLIFY || process.env.K_SERVICE);
+  }
+  processUpdate(update, options) {
+    return this.collectUpdateTasks(update, options);
+  }
+  collectUpdateTasks(update, options) {
+    const tasks = [];
+    if (this.businessMode && update.business_connection) {
+      const connection = update.business_connection;
+      const task = this.cacheBusinessConnection(connection);
+      const tracked = task.catch((error) => {
+        this.logger.warn("Failed to cache Telegram business connection", {
+          error: String(error),
+          connectionId: connection.id
+        });
+      });
+      options?.waitUntil?.(tracked);
+      tasks.push(task);
+    }
+    const messageUpdate = update.message ?? update.edited_message ?? update.channel_post ?? update.edited_channel_post;
+    const businessMessageUpdate = update.business_message ?? update.edited_business_message;
+    const userId = update.callback_query?.from.id ?? update.message_reaction?.user?.id ?? messageUpdate?.from?.id ?? businessMessageUpdate?.from?.id;
+    if (this.allowedUserIds && (userId === undefined || !this.allowedUserIds.has(String(userId)))) {
+      return tasks;
+    }
+    const handledSlashCommand = update.message !== undefined && !update.message.media_group_id && this.handleSlashCommandUpdate(update.message, this.encodeThreadId({
+      chatId: String(update.message.chat.id),
+      messageThreadId: update.message.message_thread_id
+    }), options);
+    if (handledSlashCommand && typeof handledSlashCommand !== "boolean") {
+      tasks.push(handledSlashCommand);
+    }
+    if (messageUpdate && !handledSlashCommand) {
+      const task = this.handleIncomingMessageUpdate(messageUpdate, options);
+      if (task) {
+        tasks.push(task);
+      }
+    }
+    if (update.callback_query) {
+      const task = this.handleCallbackQuery(update.callback_query, options);
+      if (task) {
+        tasks.push(task);
+      }
+    }
+    if (update.message_reaction) {
+      tasks.push(...this.handleMessageReactionUpdate(update.message_reaction, options) ?? []);
+    }
+    if (this.businessMode && businessMessageUpdate) {
+      const task = this.handleBusinessMessageUpdate(businessMessageUpdate, { isEdit: update.business_message === undefined }, options);
+      const tracked = task.catch((error) => {
+        this.logger.warn("Failed to process Telegram business message", {
+          error: String(error),
+          connectionId: businessMessageUpdate.business_connection_id
+        });
+      });
+      options?.waitUntil?.(tracked);
+      tasks.push(task);
+    }
+    return tasks;
+  }
+  businessConnectionCacheKey(connectionId) {
+    return `${this.name}:business-connection:${connectionId}`;
+  }
+  async cacheBusinessConnection(connection) {
+    if (!this.chat) {
+      return;
+    }
+    await this.chat.getState().set(this.businessConnectionCacheKey(connection.id), connection, TELEGRAM_BUSINESS_CONNECTION_TTL_MS);
+  }
+  async resolveBusinessConnection(connectionId) {
+    const state = this.chat?.getState();
+    const key = this.businessConnectionCacheKey(connectionId);
+    const cached = await state?.get(key);
+    if (cached) {
+      return cached;
+    }
+    const connection = await this.telegramFetch("getBusinessConnection", {
+      business_connection_id: connectionId
+    });
+    await state?.set(key, connection, TELEGRAM_BUSINESS_CONNECTION_TTL_MS);
+    return connection;
+  }
+  isBusinessConnectionUsable(connection) {
+    return connection.is_enabled && (connection.rights?.can_reply ?? false);
+  }
+  async handleBusinessMessageUpdate(telegramMessage, routing, options) {
+    if (!this.chat) {
+      return;
+    }
+    const connectionId = telegramMessage.business_connection_id;
+    if (!connectionId) {
+      this.logger.warn("Telegram business message missing connection id", {
+        messageId: telegramMessage.message_id
+      });
+      return;
+    }
+    const connection = await this.resolveBusinessConnection(connectionId);
+    if (!this.isBusinessConnectionUsable(connection)) {
+      this.logger.debug("Ignoring Telegram business message: connection cannot reply", {
+        connectionId,
+        isEnabled: connection.is_enabled,
+        canReply: connection.rights?.can_reply ?? false
+      });
+      return;
+    }
+    if (telegramMessage.sender_business_bot) {
+      return;
+    }
+    if (telegramMessage.from?.id === connection.user.id) {
+      this.logger.debug("Ignoring Telegram business message typed by the account owner", { connectionId, messageId: telegramMessage.message_id });
+      return;
+    }
+    const threadId = this.encodeThreadId({
+      chatId: String(telegramMessage.chat.id),
+      businessConnectionId: connectionId
+    });
+    if (telegramMessage.media_group_id) {
+      const task = this.processIncomingMediaGroup(telegramMessage, threadId, options);
+      const tracked = task.catch((error) => {
+        this.logger.warn("Failed to process incoming Telegram media group", {
+          error: String(error),
+          mediaGroupId: telegramMessage.media_group_id,
+          threadId
+        });
+      });
+      options?.waitUntil?.(tracked);
+      await task;
+      return;
+    }
+    const command = !routing.isEdit && this.handleSlashCommandUpdate(telegramMessage, threadId, options);
+    if (command) {
+      await command;
+      return;
+    }
+    this.startTypingForPrivateMessage(telegramMessage, threadId, options);
+    const parsedMessage = this.parseTelegramMessage(telegramMessage, threadId);
+    this.cacheMessage(parsedMessage);
+    await this.chat.processMessage(this, threadId, parsedMessage, options);
+  }
+  handleIncomingMessageUpdate(telegramMessage, options) {
+    if (!this.chat) {
+      return;
+    }
+    const threadId = this.encodeThreadId({
+      chatId: String(telegramMessage.chat.id),
+      messageThreadId: telegramMessage.message_thread_id
+    });
+    if (telegramMessage.media_group_id) {
+      const task = this.processIncomingMediaGroup(telegramMessage, threadId, options);
+      const tracked = task.catch((error) => {
+        this.logger.warn("Failed to process incoming Telegram media group", {
+          error: String(error),
+          mediaGroupId: telegramMessage.media_group_id,
+          threadId
+        });
+      });
+      options?.waitUntil?.(tracked);
+      return task;
+    }
+    this.startTypingForPrivateMessage(telegramMessage, threadId, options);
+    const parsedMessage = this.parseTelegramMessage(telegramMessage, threadId);
+    this.cacheMessage(parsedMessage);
+    return this.chat.processMessage(this, threadId, parsedMessage, options);
+  }
+  async processIncomingMediaGroup(telegramMessage, threadId, options) {
+    if (!(this.chat && telegramMessage.media_group_id)) {
+      return;
+    }
+    const state = this.chat.getState();
+    const mediaGroupKey = `${this.name}:incoming-media-group:${threadId}:${telegramMessage.media_group_id}`;
+    const lockKey = `${mediaGroupKey}:lock`;
+    let appended = false;
+    for (;; ) {
+      const lock = await state.acquireLock(lockKey, TELEGRAM_INCOMING_MEDIA_GROUP_LOCK_TTL_MS);
+      if (!lock) {
+        await this.sleep(TELEGRAM_INCOMING_MEDIA_GROUP_RETRY_MS);
+        continue;
+      }
+      let entries = [];
+      let remainingSettleMs = 0;
+      try {
+        entries = await state.get(mediaGroupKey) ?? [];
+        if (!appended) {
+          entries = entries.filter((entry) => entry.message.message_id !== telegramMessage.message_id);
+          entries.push({ message: telegramMessage, receivedAt: Date.now() });
+          await state.set(mediaGroupKey, entries.slice(-TELEGRAM_MEDIA_GROUP_MAX), TELEGRAM_INCOMING_MEDIA_GROUP_BUFFER_TTL_MS);
+          appended = true;
+          remainingSettleMs = TELEGRAM_INCOMING_MEDIA_GROUP_SETTLE_MS;
+        } else if (entries.length === 0) {
+          return;
+        } else {
+          const newestReceivedAt = Math.max(...entries.map((entry) => entry.receivedAt));
+          remainingSettleMs = Math.max(0, TELEGRAM_INCOMING_MEDIA_GROUP_SETTLE_MS - (Date.now() - newestReceivedAt));
+          if (remainingSettleMs === 0) {
+            await state.delete(mediaGroupKey);
+          }
+        }
+      } finally {
+        await state.releaseLock(lock);
+      }
+      if (remainingSettleMs > 0) {
+        await this.sleep(remainingSettleMs);
+        continue;
+      }
+      const orderedMessages = entries.map((entry) => entry.message).sort((left, right) => left.message_id - right.message_id);
+      const parsedMessages = orderedMessages.map((message) => this.parseTelegramMessage(message, threadId));
+      const latestMessage = parsedMessages.at(-1);
+      if (!latestMessage) {
+        return;
+      }
+      const contentMessage = parsedMessages.find((message) => message.text.length > 0) ?? latestMessage;
+      const combinedMessage = new Message({
+        id: latestMessage.id,
+        threadId,
+        text: contentMessage.text,
+        formatted: contentMessage.formatted,
+        raw: latestMessage.raw,
+        author: latestMessage.author,
+        metadata: latestMessage.metadata,
+        attachments: parsedMessages.flatMap((message) => message.attachments),
+        replyTo: parsedMessages.find((message) => message.replyTo)?.replyTo,
+        isMention: parsedMessages.some((message) => message.isMention),
+        links: parsedMessages.flatMap((message) => message.links)
+      });
+      this.startTypingForPrivateMessage(orderedMessages[0], threadId);
+      this.cacheMessage(combinedMessage);
+      await this.chat.processMessage(this, threadId, combinedMessage, options);
+      return;
+    }
+  }
+  handleSlashCommandUpdate(telegramMessage, threadId, options) {
+    if (!this.chat) {
+      return false;
+    }
+    const slashCommand = this.parseSlashCommand(telegramMessage);
+    if (!slashCommand) {
+      return false;
+    }
+    this.startTypingForPrivateMessage(telegramMessage, threadId, options);
+    const parsedMessage = this.parseTelegramMessage(telegramMessage, threadId);
+    this.cacheMessage(parsedMessage);
+    return Promise.resolve(this.chat.processSlashCommand({
+      adapter: this,
+      channelId: threadId,
+      command: slashCommand.command,
+      text: slashCommand.text,
+      user: parsedMessage.author,
+      raw: telegramMessage
+    }, options));
+  }
+  startTypingForPrivateMessage(telegramMessage, threadId, options) {
+    if (telegramMessage.chat.type !== "private" || telegramMessage.from?.is_bot) {
+      return;
+    }
+    const typingTask = this.startTyping(threadId).catch((error) => {
+      this.logger.warn("Failed to send Telegram typing action", {
+        error: String(error),
+        threadId
+      });
+    });
+    options?.waitUntil?.(typingTask);
+  }
+  parseSlashCommand(telegramMessage) {
+    const hasText = telegramMessage.text !== undefined;
+    const text2 = hasText ? telegramMessage.text : telegramMessage.caption;
+    const entities = hasText ? telegramMessage.entities ?? [] : telegramMessage.caption_entities ?? [];
+    if (!text2) {
+      return null;
+    }
+    const commandEntity = entities.find((entity) => entity.type === "bot_command" && entity.offset === 0);
+    if (!commandEntity) {
+      return null;
+    }
+    const rawCommand = this.entityText(text2, commandEntity);
+    if (!rawCommand.startsWith("/")) {
+      return null;
+    }
+    const commandWithoutSlash = rawCommand.slice(1);
+    const atIndex = commandWithoutSlash.indexOf("@");
+    const commandName = atIndex === -1 ? commandWithoutSlash : commandWithoutSlash.slice(0, atIndex);
+    const targetBot = atIndex === -1 ? undefined : commandWithoutSlash.slice(atIndex + 1);
+    if (!commandName) {
+      return null;
+    }
+    if (targetBot && targetBot.toLowerCase() !== this.userName.toLowerCase()) {
+      return null;
+    }
+    return {
+      command: `/${commandName}`,
+      text: text2.slice(commandEntity.offset + commandEntity.length).trimStart()
+    };
+  }
+  handleCallbackQuery(callbackQuery, options) {
+    if (!(this.chat && callbackQuery.message)) {
+      return;
+    }
+    const threadId = this.encodeThreadId({
+      chatId: String(callbackQuery.message.chat.id),
+      messageThreadId: callbackQuery.message.message_thread_id,
+      businessConnectionId: callbackQuery.message.business_connection_id
+    });
+    const messageId = this.encodeMessageId(String(callbackQuery.message.chat.id), callbackQuery.message.message_id);
+    const { actionId, value } = decodeTelegramCallbackData(callbackQuery.data);
+    const task = this.chat.processAction({
+      adapter: this,
+      actionId,
+      value,
+      messageId,
+      threadId,
+      user: this.toAuthor(callbackQuery.from),
+      raw: callbackQuery
+    }, options);
+    const ackTask = this.telegramFetch("answerCallbackQuery", {
+      callback_query_id: callbackQuery.id
+    }).catch((error) => {
+      this.logger.warn("Failed to acknowledge Telegram callback query", {
+        callbackQueryId: callbackQuery.id,
+        error: String(error)
+      });
+    });
+    if (options?.waitUntil) {
+      options.waitUntil(ackTask);
+    }
+    return task;
+  }
+  handleMessageReactionUpdate(reactionUpdate, options) {
+    const tasks = [];
+    if (!this.chat) {
+      return tasks;
+    }
+    const threadId = this.encodeThreadId({
+      chatId: String(reactionUpdate.chat.id),
+      messageThreadId: reactionUpdate.message_thread_id
+    });
+    const messageId = this.encodeMessageId(String(reactionUpdate.chat.id), reactionUpdate.message_id);
+    const oldReactions = new Set(reactionUpdate.old_reaction.map((reaction) => this.reactionKey(reaction)));
+    const newReactions = new Set(reactionUpdate.new_reaction.map((reaction) => this.reactionKey(reaction)));
+    const actor = reactionUpdate.user ? this.toAuthor(reactionUpdate.user) : this.toReactionActorAuthor(reactionUpdate.chat);
+    for (const reaction of reactionUpdate.new_reaction) {
+      const key = this.reactionKey(reaction);
+      if (!oldReactions.has(key)) {
+        const task = this.chat.processReaction({
+          adapter: this,
+          threadId,
+          messageId,
+          emoji: this.reactionToEmojiValue(reaction),
+          rawEmoji: key,
+          added: true,
+          user: actor,
+          raw: reactionUpdate
+        }, options);
+        if (task) {
+          tasks.push(task);
+        }
+      }
+    }
+    for (const reaction of reactionUpdate.old_reaction) {
+      const key = this.reactionKey(reaction);
+      if (!newReactions.has(key)) {
+        const task = this.chat.processReaction({
+          adapter: this,
+          threadId,
+          messageId,
+          emoji: this.reactionToEmojiValue(reaction),
+          rawEmoji: key,
+          added: false,
+          user: actor,
+          raw: reactionUpdate
+        }, options);
+        if (task) {
+          tasks.push(task);
+        }
+      }
+    }
+    return tasks;
+  }
+  async postMessage(threadId, message, replyToMessageId) {
+    const parsedThread = this.resolveThreadId(threadId);
+    const replyParameters = this.buildReplyParameters(replyToMessageId, parsedThread.chatId);
+    const card = extractCard(message);
+    const replyMarkup = card ? cardToTelegramInlineKeyboard(card) : undefined;
+    const parseMode = this.resolveParseMode(message, card);
+    const plainText = truncateForTelegram(convertEmojiPlaceholders(this.renderPlainTextMessage(message, card), "gchat"), TELEGRAM_MESSAGE_LIMIT, "plain");
+    const text2 = truncateForTelegram(convertEmojiPlaceholders(card ? this.formatConverter.fromMarkdown(cardToFallbackText(card, { boldFormat: "**" })) : this.formatConverter.renderPostable(message), "gchat"), TELEGRAM_MESSAGE_LIMIT, parseMode);
+    const files = extractFiles(message);
+    const attachments = extractPostableAttachments(message);
+    if (files.length > 0 && attachments.length > 0) {
+      throw new ValidationError("telegram", "Telegram adapter does not support mixing file uploads and attachments in one message");
+    }
+    const rich = this.resolveRichMessage(message, card, files.length, attachments.length);
+    let rawMessages;
+    if (files.length > 0) {
+      const [file] = files;
+      if (!file) {
+        throw new ValidationError("telegram", "File upload payload is empty");
+      }
+      rawMessages = files.length === 1 ? [
+        await this.sendDocument(parsedThread, file, text2, plainText, replyMarkup, parseMode, replyParameters)
+      ] : await this.sendDocumentMediaGroup(parsedThread, files, text2, plainText, replyMarkup, parseMode, replyParameters);
+    } else if (attachments.length > 0) {
+      const [attachment] = attachments;
+      if (!attachment) {
+        throw new ValidationError("telegram", "Attachment upload payload is empty");
+      }
+      rawMessages = attachments.length === 1 ? [
+        await this.sendAttachment(parsedThread, attachment, text2, plainText, replyMarkup, parseMode, replyParameters)
+      ] : await this.sendAttachmentMediaGroup(parsedThread, attachments, text2, plainText, replyMarkup, parseMode, replyParameters);
+    } else {
+      if (!text2.trim()) {
+        throw new ValidationError("telegram", "Message text cannot be empty");
+      }
+      const sendRegular = () => this.sendRegularMessage(parsedThread, text2, plainText, parseMode, replyMarkup, threadId, replyParameters);
+      rawMessages = [
+        rich ? await this.withTelegramRichFallback(() => this.telegramFetch("sendRichMessage", {
+          ...this.buildChatTargetParams(parsedThread),
+          rich_message: {
+            markdown: rich.markdown
+          },
+          reply_markup: replyMarkup,
+          reply_parameters: replyParameters
+        }), sendRegular, {
+          method: "sendRichMessage",
+          threadId
+        }) : await sendRegular()
+      ];
+    }
+    const parsedMessages = rawMessages.map((rawMessage) => this.parseTelegramMessage(rawMessage, this.encodeThreadId({
+      chatId: String(rawMessage.chat.id),
+      messageThreadId: rawMessage.message_thread_id ?? parsedThread.messageThreadId,
+      businessConnectionId: parsedThread.businessConnectionId
+    }), rich ? {
+      formatted: rich.formatted,
+      text: rich.text
+    } : undefined));
+    for (const parsedMessage of parsedMessages) {
+      this.cacheMessage(parsedMessage);
+    }
+    const sentMessage = parsedMessages.at(-1);
+    if (!sentMessage) {
+      throw new NetworkError("telegram", "Telegram postMessage did not return any sent messages");
+    }
+    return {
+      id: sentMessage.id,
+      threadId: sentMessage.threadId,
+      raw: sentMessage.raw
+    };
+  }
+  async postChannelMessage(channelId, message) {
+    return this.postMessage(channelId, message);
+  }
+  async reply(threadId, messageId, message) {
+    return this.postMessage(threadId, message, messageId);
+  }
+  async editMessage(threadId, messageId, message) {
+    const parsedThread = this.resolveThreadId(threadId);
+    const { messageId: telegramMessageId, compositeId } = this.decodeCompositeMessageId(messageId, parsedThread.chatId);
+    const card = extractCard(message);
+    const replyMarkup = card ? cardToTelegramInlineKeyboard(card) : undefined;
+    const parseMode = this.resolveParseMode(message, card);
+    const plainText = truncateForTelegram(convertEmojiPlaceholders(this.renderPlainTextMessage(message, card), "gchat"), TELEGRAM_MESSAGE_LIMIT, "plain");
+    const text2 = truncateForTelegram(convertEmojiPlaceholders(card ? this.formatConverter.fromMarkdown(cardToFallbackText(card, { boldFormat: "**" })) : this.formatConverter.renderPostable(message), "gchat"), TELEGRAM_MESSAGE_LIMIT, parseMode);
+    const rich = this.resolveRichMessage(message, card, 0, 0);
+    if (!text2.trim()) {
+      throw new ValidationError("telegram", "Message text cannot be empty");
+    }
+    const editRegular = () => this.withTelegramMarkdownFallback(parseMode, (resolvedParseMode, resolvedText) => this.telegramFetch("editMessageText", {
+      ...this.buildChatTargetParams(parsedThread),
+      message_id: telegramMessageId,
+      text: resolvedText,
+      reply_markup: replyMarkup ?? emptyTelegramInlineKeyboard(),
+      parse_mode: toBotApiParseMode(resolvedParseMode)
+    }), {
+      initialText: text2,
+      fallbackText: plainText,
+      messageId,
+      method: "editMessageText",
+      threadId
+    });
+    const result = rich ? await this.withTelegramRichFallback(() => this.telegramFetch("editMessageText", {
+      ...this.buildChatTargetParams(parsedThread),
+      message_id: telegramMessageId,
+      rich_message: {
+        markdown: rich.markdown
+      },
+      reply_markup: replyMarkup ?? emptyTelegramInlineKeyboard()
+    }), editRegular, {
+      messageId,
+      method: "editMessageText",
+      threadId
+    }) : await editRegular();
+    if (result === true) {
+      const existing = this.findCachedMessage(compositeId);
+      if (!existing) {
+        throw new NotImplementedError("Telegram returned a non-message edit result and no cached message was found", "editMessage");
+      }
+      const updated = new Message({
+        ...existing,
+        text: rich?.text ?? text2,
+        formatted: rich?.formatted ?? this.formatConverter.toAst(text2),
+        metadata: {
+          ...existing.metadata,
+          edited: true,
+          editedAt: /* @__PURE__ */ new Date
+        }
+      });
+      this.cacheMessage(updated);
+      return {
+        id: updated.id,
+        threadId: updated.threadId,
+        raw: updated.raw
+      };
+    }
+    const resultingThreadId = this.encodeThreadId({
+      chatId: String(result.chat.id),
+      messageThreadId: result.message_thread_id ?? parsedThread.messageThreadId,
+      businessConnectionId: parsedThread.businessConnectionId
+    });
+    const parsedMessage = this.parseTelegramMessage(result, resultingThreadId, rich ? {
+      formatted: rich.formatted,
+      text: rich.text
+    } : undefined);
+    this.cacheMessage(parsedMessage);
+    return {
+      id: parsedMessage.id,
+      threadId: parsedMessage.threadId,
+      raw: result
+    };
+  }
+  async deleteMessage(threadId, messageId) {
+    const parsedThread = this.resolveThreadId(threadId);
+    const { messageId: telegramMessageId, compositeId } = this.decodeCompositeMessageId(messageId, parsedThread.chatId);
+    if (parsedThread.businessConnectionId) {
+      await this.telegramFetch("deleteBusinessMessages", {
+        business_connection_id: parsedThread.businessConnectionId,
+        message_ids: [telegramMessageId]
+      });
+    } else {
+      await this.telegramFetch("deleteMessage", {
+        chat_id: parsedThread.chatId,
+        message_id: telegramMessageId
+      });
+    }
+    this.deleteCachedMessage(compositeId);
+  }
+  async addReaction(threadId, messageId, emoji) {
+    const parsedThread = this.resolveThreadId(threadId);
+    this.assertReactionsSupported(parsedThread, "addReaction");
+    const { messageId: telegramMessageId } = this.decodeCompositeMessageId(messageId, parsedThread.chatId);
+    await this.telegramFetch("setMessageReaction", {
+      chat_id: parsedThread.chatId,
+      message_id: telegramMessageId,
+      reaction: [this.toTelegramReaction(emoji)]
+    });
+  }
+  async removeReaction(threadId, messageId, _emoji) {
+    const parsedThread = this.resolveThreadId(threadId);
+    this.assertReactionsSupported(parsedThread, "removeReaction");
+    const { messageId: telegramMessageId } = this.decodeCompositeMessageId(messageId, parsedThread.chatId);
+    await this.telegramFetch("setMessageReaction", {
+      chat_id: parsedThread.chatId,
+      message_id: telegramMessageId,
+      reaction: []
+    });
+  }
+  assertReactionsSupported(thread, method) {
+    if (thread.businessConnectionId) {
+      throw new NotImplementedError("Telegram Bot API does not support reactions on behalf of a business account", method);
+    }
+  }
+  async startTyping(threadId) {
+    const parsedThread = this.resolveThreadId(threadId);
+    await this.telegramFetch("sendChatAction", {
+      ...this.buildChatTargetParams(parsedThread),
+      action: "typing"
+    });
+  }
+  async stream(threadId, textStream, options) {
+    if (this.nativeStreaming && this.isDM(threadId)) {
+      return await this.nativeDraftStream(threadId, textStream, options);
+    }
+    return await this.postAndEditStream(threadId, textStream, options);
+  }
+  async postAndEditStream(threadId, textStream, options) {
+    const defaultIntervalMs = this.isDM(threadId) ? TELEGRAM_DEFAULT_PRIVATE_STREAMING_EDIT_INTERVAL_MS : TELEGRAM_DEFAULT_NON_PRIVATE_STREAMING_EDIT_INTERVAL_MS;
+    const intervalMs = Math.max(this.clampInteger(options?.updateIntervalMs, 0, 0, Number.MAX_SAFE_INTEGER), this.streamingEditIntervalMs ?? defaultIntervalMs);
+    const placeholderText = options?.fallbackStreamingPlaceholderText === undefined ? TELEGRAM_STREAM_PLACEHOLDER_TEXT : options.fallbackStreamingPlaceholderText;
+    const renderer = new StreamingMarkdownRenderer;
+    let accumulated = "";
+    let posted = null;
+    let editThreadId = threadId;
+    let lastEditContent = "";
+    let lastEditAt = 0;
+    let blockedUntil = 0;
+    let rateLimitError = null;
+    if (placeholderText !== null) {
+      posted = await this.postMessage(threadId, placeholderText);
+      editThreadId = posted.threadId || threadId;
+      lastEditContent = placeholderText;
+      lastEditAt = Date.now();
+    }
+    const applyEdit = async (content) => {
+      if (!posted) {
+        return;
+      }
+      posted = await this.editMessage(editThreadId, posted.id, {
+        markdown: content
+      });
+      editThreadId = posted.threadId || editThreadId;
+      lastEditContent = content;
+      lastEditAt = Date.now();
+      blockedUntil = 0;
+      rateLimitError = null;
+    };
+    const rememberRateLimit = (error) => {
+      const retryAfterMs = Math.max(0, error.retryAfter ?? 1) * 1000;
+      blockedUntil = Math.max(blockedUntil, Date.now() + retryAfterMs);
+      rateLimitError = error;
+    };
+    const shouldEdit = (content) => Boolean(posted) && content.trim().length > 0 && content !== lastEditContent;
+    const flushEdit = async (content) => {
+      if (!shouldEdit(content)) {
+        return;
+      }
+      try {
+        await applyEdit(content);
+      } catch (error) {
+        if (error instanceof AdapterRateLimitError) {
+          rememberRateLimit(error);
+        }
+        this.logger.warn("Telegram stream edit failed", {
+          error: String(error),
+          threadId
+        });
+      }
+    };
+    const flushFinalEdit = async (content) => {
+      if (!shouldEdit(content)) {
+        return;
+      }
+      const blockedMs = Math.max(0, blockedUntil - Date.now());
+      const pacingMs = Math.max(0, intervalMs - (Date.now() - lastEditAt));
+      if (blockedMs > TELEGRAM_STREAM_FINAL_EDIT_RETRY_CAP_MS && rateLimitError) {
+        throw rateLimitError;
+      }
+      await this.sleep(Math.max(blockedMs, pacingMs));
+      try {
+        await applyEdit(content);
+        return;
+      } catch (error) {
+        if (!(error instanceof AdapterRateLimitError)) {
+          throw error;
+        }
+        rememberRateLimit(error);
+        const retryAfterMs = (error.retryAfter ?? 1) * 1000;
+        if (retryAfterMs > TELEGRAM_STREAM_FINAL_EDIT_RETRY_CAP_MS) {
+          throw error;
+        }
+        await this.sleep(retryAfterMs);
+      }
+      await applyEdit(content);
+    };
+    for await (const chunk of textStream) {
+      let text2 = null;
+      if (typeof chunk === "string") {
+        text2 = chunk;
+      } else if (chunk.type === "markdown_text") {
+        text2 = chunk.text;
+      }
+      if (text2 === null) {
+        continue;
+      }
+      accumulated += text2;
+      renderer.push(text2);
+      if (posted) {
+        if (Date.now() >= blockedUntil && Date.now() - lastEditAt >= intervalMs) {
+          await flushEdit(renderer.render());
+        }
+        continue;
+      }
+      const initial = renderer.render();
+      if (initial.trim()) {
+        posted = await this.postMessage(threadId, { markdown: initial });
+        editThreadId = posted.threadId || threadId;
+        lastEditContent = initial;
+        lastEditAt = Date.now();
+      }
+    }
+    const finalContent = renderer.finish();
+    if (posted) {
+      await flushFinalEdit(finalContent);
+      return posted;
+    }
+    if (!accumulated.trim()) {
+      throw new ValidationError("telegram", "Telegram streaming requires text content");
+    }
+    return await this.postMessage(threadId, { markdown: accumulated });
+  }
+  async nativeDraftStream(threadId, textStream, options) {
+    const parsedThread = this.resolveThreadId(threadId);
+    const updateIntervalMs = this.clampInteger(options?.updateIntervalMs, TELEGRAM_DEFAULT_STREAM_UPDATE_INTERVAL_MS, 0, Number.MAX_SAFE_INTEGER);
+    const renderer = new StreamingMarkdownRenderer;
+    const draftId = this.createDraftId();
+    let accumulated = "";
+    let lastDraftText = null;
+    let lastFlushAt = 0;
+    let draftStreamingEnabled = true;
+    let streamUsesMarkdown = true;
+    let streamUsesRich = this.richMessagesAvailable;
+    const renderMarkdownForTelegram = (text2) => convertEmojiPlaceholders(this.formatConverter.fromMarkdown(text2), "gchat");
+    const renderMarkdownText = (text2) => truncateForTelegram(renderMarkdownForTelegram(text2), TELEGRAM_MESSAGE_LIMIT, "MarkdownV2");
+    const renderPlainText = (text2) => truncateForTelegram(this.resolveTelegramFallbackText(text2, markdownToPlainText(text2)), TELEGRAM_MESSAGE_LIMIT, "plain");
+    const sendDraft = async (text2, useMarkdown) => {
+      if (!draftStreamingEnabled || text2 === lastDraftText) {
+        return;
+      }
+      let draftText = text2;
+      if (streamUsesRich) {
+        try {
+          await this.telegramFetch("sendRichMessageDraft", {
+            ...this.buildChatTargetParams(parsedThread),
+            draft_id: draftId,
+            rich_message: {
+              markdown: text2
+            }
+          });
+          lastDraftText = text2;
+          lastFlushAt = Date.now();
+          return;
+        } catch (error) {
+          if (!this.canFallbackFromRichMessage(error, "sendRichMessageDraft")) {
+            draftStreamingEnabled = false;
+            this.logger.warn("Telegram rich draft streaming update failed", {
+              error: String(error),
+              threadId
+            });
+            return;
+          }
+          this.rememberRichMessageFailure(error, "sendRichMessageDraft");
+          this.logger.warn("Telegram rich draft failed; retrying with a regular draft", {
+            error: String(error),
+            threadId
+          });
+          streamUsesRich = false;
+          draftText = useMarkdown ? renderMarkdownText(renderer.render()) : renderPlainText(accumulated);
+        }
+      }
+      try {
+        if (useMarkdown) {
+          await this.telegramFetch("sendMessageDraft", {
+            ...this.buildChatTargetParams(parsedThread),
+            draft_id: draftId,
+            text: draftText,
+            parse_mode: toBotApiParseMode("MarkdownV2")
+          });
+        } else {
+          await this.telegramFetch("sendMessageDraft", {
+            ...this.buildChatTargetParams(parsedThread),
+            draft_id: draftId,
+            text: draftText
+          });
+        }
+        lastDraftText = draftText;
+        lastFlushAt = Date.now();
+      } catch (error) {
+        if (useMarkdown && this.isTelegramMarkdownParseError(error)) {
+          streamUsesMarkdown = false;
+          const plainDraftText = renderPlainText(accumulated);
+          try {
+            await this.telegramFetch("sendMessageDraft", {
+              ...this.buildChatTargetParams(parsedThread),
+              draft_id: draftId,
+              text: plainDraftText
+            });
+            lastDraftText = plainDraftText;
+            lastFlushAt = Date.now();
+          } catch (retryError) {
+            draftStreamingEnabled = false;
+            this.logger.warn("Telegram draft streaming update failed", {
+              error: String(retryError),
+              threadId
+            });
+          }
+          return;
+        }
+        draftStreamingEnabled = false;
+        this.logger.warn("Telegram draft streaming update failed", {
+          error: String(error),
+          threadId
+        });
+      }
+    };
+    const flushDraft = async () => {
+      if (!draftStreamingEnabled) {
+        return;
+      }
+      let draftText;
+      if (streamUsesRich) {
+        draftText = truncateRichMarkdown(renderer.render());
+      } else if (streamUsesMarkdown) {
+        draftText = renderMarkdownText(renderer.render());
+      } else {
+        draftText = renderPlainText(accumulated);
+      }
+      await sendDraft(draftText, streamUsesMarkdown);
+    };
+    for await (const chunk of textStream) {
+      let text2 = null;
+      if (typeof chunk === "string") {
+        text2 = chunk;
+      } else if (chunk.type === "markdown_text") {
+        text2 = chunk.text;
+      }
+      if (text2 === null) {
+        continue;
+      }
+      accumulated += text2;
+      renderer.push(text2);
+      if (Date.now() - lastFlushAt >= updateIntervalMs) {
+        await flushDraft();
+      }
+    }
+    if (!accumulated.trim()) {
+      throw new ValidationError("telegram", "Telegram streaming requires text content");
+    }
+    const finalMarkdown = renderer.finish();
+    await flushDraft();
+    if (streamUsesRich) {
+      const markdown = truncateRichMarkdown(finalMarkdown);
+      try {
+        const raw2 = await this.telegramFetch("sendRichMessage", {
+          ...this.buildChatTargetParams(parsedThread),
+          rich_message: {
+            markdown
+          }
+        });
+        const resultingThreadId2 = this.encodeThreadId({
+          chatId: String(raw2.chat.id),
+          messageThreadId: raw2.message_thread_id ?? parsedThread.messageThreadId,
+          businessConnectionId: parsedThread.businessConnectionId
+        });
+        const formatted = this.formatConverter.toAst(accumulated);
+        const message2 = this.parseTelegramMessage(raw2, resultingThreadId2, {
+          formatted,
+          text: toPlainText(formatted)
+        });
+        this.cacheMessage(message2);
+        return {
+          id: message2.id,
+          threadId: message2.threadId,
+          raw: raw2
+        };
+      } catch (error) {
+        if (!this.canFallbackFromRichMessage(error, "sendRichMessage")) {
+          throw error;
+        }
+        this.rememberRichMessageFailure(error, "sendRichMessage");
+      }
+    }
+    const regularText = streamUsesMarkdown ? renderMarkdownText(finalMarkdown) : renderPlainText(accumulated);
+    const plainText = renderPlainText(accumulated);
+    const raw = await this.sendRegularMessage(parsedThread, regularText, plainText, streamUsesMarkdown ? "MarkdownV2" : "plain", undefined, threadId);
+    const resultingThreadId = this.encodeThreadId({
+      chatId: String(raw.chat.id),
+      messageThreadId: raw.message_thread_id ?? parsedThread.messageThreadId,
+      businessConnectionId: parsedThread.businessConnectionId
+    });
+    const message = this.parseTelegramMessage(raw, resultingThreadId);
+    this.cacheMessage(message);
+    return {
+      id: message.id,
+      threadId: message.threadId,
+      raw
+    };
+  }
+  async fetchMessages(threadId, options = {}) {
+    const messages = [...this.messageCache.get(threadId) ?? []].sort((a, b) => this.compareMessages(a, b));
+    return this.paginateMessages(messages, options);
+  }
+  async fetchChannelMessages(channelId, options = {}) {
+    const byId = /* @__PURE__ */ new Map;
+    for (const [threadId, messages] of this.messageCache.entries()) {
+      let decoded;
+      try {
+        decoded = this.decodeThreadId(threadId);
+      } catch {
+        continue;
+      }
+      if (decoded.chatId !== channelId) {
+        continue;
+      }
+      for (const message of messages) {
+        byId.set(message.id, message);
+      }
+    }
+    const allMessages = [...byId.values()].sort((a, b) => this.compareMessages(a, b));
+    return this.paginateMessages(allMessages, options);
+  }
+  async fetchMessage(_threadId, messageId) {
+    return this.findCachedMessage(messageId) ?? null;
+  }
+  async fetchThread(threadId) {
+    const parsedThread = this.resolveThreadId(threadId);
+    const encodedThreadId = this.encodeThreadId(parsedThread);
+    if (parsedThread.businessConnectionId) {
+      const chat2 = await this.fetchBusinessChat(parsedThread, encodedThreadId);
+      return {
+        id: encodedThreadId,
+        channelId: parsedThread.chatId,
+        channelName: chat2 ? this.chatDisplayName(chat2) : undefined,
+        isDM: true,
+        metadata: {
+          chat: chat2,
+          businessConnectionId: parsedThread.businessConnectionId
+        }
+      };
+    }
+    const chat = await this.telegramFetch("getChat", {
+      chat_id: parsedThread.chatId
+    });
+    return {
+      id: encodedThreadId,
+      channelId: String(chat.id),
+      channelName: this.chatDisplayName(chat),
+      isDM: chat.type === "private",
+      metadata: {
+        chat,
+        messageThreadId: parsedThread.messageThreadId
+      }
+    };
+  }
+  async fetchBusinessChat(thread, threadId) {
+    const cachedChat = this.messageCache.get(threadId)?.at(-1)?.raw.chat;
+    try {
+      return await this.telegramFetch("getChat", {
+        chat_id: thread.chatId
+      });
+    } catch (error) {
+      if (!cachedChat) {
+        throw error;
+      }
+      this.logger.debug("Telegram getChat failed for business thread, using cached chat", { error: String(error), threadId });
+      return cachedChat;
+    }
+  }
+  async fetchChannelInfo(channelId) {
+    const chat = await this.telegramFetch("getChat", {
+      chat_id: channelId
+    });
+    let memberCount;
+    try {
+      memberCount = await this.telegramFetch("getChatMemberCount", {
+        chat_id: channelId
+      });
+    } catch {
+      memberCount = undefined;
+    }
+    return {
+      id: String(chat.id),
+      name: this.chatDisplayName(chat),
+      isDM: chat.type === "private",
+      memberCount,
+      metadata: {
+        chat
+      }
+    };
+  }
+  channelIdFromThreadId(threadId) {
+    const { chatId, businessConnectionId } = this.resolveThreadId(threadId);
+    if (businessConnectionId) {
+      return this.encodeThreadId({ chatId, businessConnectionId });
+    }
+    return `telegram:${chatId}`;
+  }
+  async openDM(userId) {
+    return this.encodeThreadId({ chatId: userId });
+  }
+  isDM(threadId) {
+    const { chatId } = this.resolveThreadId(threadId);
+    return !chatId.startsWith("-");
+  }
+  encodeThreadId(platformData) {
+    if (platformData.businessConnectionId) {
+      return `telegram:biz:${platformData.businessConnectionId}:${platformData.chatId}`;
+    }
+    if (typeof platformData.messageThreadId === "number") {
+      return `telegram:${platformData.chatId}:${platformData.messageThreadId}`;
+    }
+    return `telegram:${platformData.chatId}`;
+  }
+  decodeThreadId(threadId) {
+    const parts = threadId.split(":");
+    if (parts[0] !== "telegram") {
+      throw new ValidationError("telegram", `Invalid Telegram thread ID: ${threadId}`);
+    }
+    if (parts[1] === "biz") {
+      if (parts.length !== 4) {
+        throw new ValidationError("telegram", `Invalid Telegram business thread ID: ${threadId}`);
+      }
+      const businessConnectionId = parts[2];
+      const chatId2 = parts[3];
+      if (!(businessConnectionId && chatId2)) {
+        throw new ValidationError("telegram", `Invalid Telegram business thread ID: ${threadId}`);
+      }
+      return {
+        chatId: chatId2,
+        businessConnectionId
+      };
+    }
+    if (parts.length < 2 || parts.length > 3) {
+      throw new ValidationError("telegram", `Invalid Telegram thread ID: ${threadId}`);
+    }
+    const chatId = parts[1];
+    if (!chatId) {
+      throw new ValidationError("telegram", `Invalid Telegram thread ID: ${threadId}`);
+    }
+    const messageThreadPart = parts[2];
+    if (!messageThreadPart) {
+      return { chatId };
+    }
+    const messageThreadId = Number.parseInt(messageThreadPart, 10);
+    if (!Number.isFinite(messageThreadId)) {
+      throw new ValidationError("telegram", `Invalid Telegram thread topic ID in thread ID: ${threadId}`);
+    }
+    return {
+      chatId,
+      messageThreadId
+    };
+  }
+  parseMessage(raw) {
+    const threadId = this.encodeThreadId({
+      chatId: String(raw.chat.id),
+      messageThreadId: raw.message_thread_id
+    });
+    const message = this.parseTelegramMessage(raw, threadId);
+    this.cacheMessage(message);
+    return message;
+  }
+  renderFormatted(content) {
+    return this.formatConverter.fromAst(content);
+  }
+  parseTelegramMessage(raw, threadId, content) {
+    const richMarkdown = raw.rich_message ? richMessageToMarkdown(raw.rich_message) : "";
+    const plainText = content?.text ?? raw.text ?? raw.caption ?? (raw.sticker ? raw.sticker.emoji ?? raw.sticker.set_name ?? "sticker" : undefined) ?? describeNonFileContent(raw) ?? (raw.rich_message ? richMessageToText(raw.rich_message) : "");
+    const entities = raw.entities ?? raw.caption_entities ?? [];
+    const text2 = content?.text ? content.text : applyTelegramEntities(plainText, entities);
+    let author;
+    if (raw.sender_business_bot) {
+      author = this.toAuthor(raw.sender_business_bot);
+    } else if (raw.from) {
+      author = this.toAuthor(raw.from);
+    } else if (raw.sender_chat) {
+      author = this.toReactionActorAuthor(raw.sender_chat);
+    } else {
+      const fallbackName = this.chatDisplayName(raw.chat) ?? String(raw.chat.id);
+      author = {
+        userId: String(raw.chat.id),
+        userName: fallbackName,
+        fullName: fallbackName,
+        isBot: "unknown",
+        isMe: false
+      };
+    }
+    const message = new Message({
+      id: this.encodeMessageId(String(raw.chat.id), raw.message_id),
+      threadId,
+      text: text2,
+      formatted: content?.formatted ?? this.formatConverter.toAst(richMarkdown || text2),
+      raw,
+      author,
+      metadata: {
+        dateSent: new Date(raw.date * 1000),
+        edited: raw.edit_date !== undefined,
+        editedAt: raw.edit_date !== undefined ? new Date(raw.edit_date * 1000) : undefined
+      },
+      attachments: this.extractAttachments(raw),
+      replyTo: raw.reply_to_message ? this.parseTelegramMessage(raw.reply_to_message, threadId) : undefined,
+      isMention: this.isBotMentioned(raw, plainText)
+    });
+    return message;
+  }
+  extractAttachments(raw) {
+    const attachments = [];
+    const photo = raw.photo?.at(-1);
+    if (photo) {
+      attachments.push(this.createAttachment("image", photo.file_id, {
+        size: photo.file_size,
+        width: photo.width,
+        height: photo.height,
+        fileUniqueId: photo.file_unique_id,
+        mimeType: "image/jpeg"
+      }));
+    }
+    if (raw.video) {
+      attachments.push(this.createAttachment("video", raw.video.file_id, {
+        size: raw.video.file_size,
+        width: raw.video.width,
+        height: raw.video.height,
+        name: raw.video.file_name,
+        mimeType: raw.video.mime_type,
+        fileUniqueId: raw.video.file_unique_id
+      }));
+    }
+    if (raw.audio) {
+      attachments.push(this.createAttachment("audio", raw.audio.file_id, {
+        size: raw.audio.file_size,
+        name: raw.audio.file_name,
+        mimeType: raw.audio.mime_type,
+        fileUniqueId: raw.audio.file_unique_id
+      }));
+    }
+    if (raw.voice) {
+      attachments.push(this.createAttachment("audio", raw.voice.file_id, {
+        size: raw.voice.file_size,
+        mimeType: raw.voice.mime_type,
+        fileUniqueId: raw.voice.file_unique_id
+      }));
+    }
+    if (raw.document && !raw.animation) {
+      attachments.push(this.createAttachment("file", raw.document.file_id, {
+        size: raw.document.file_size,
+        name: raw.document.file_name,
+        mimeType: raw.document.mime_type,
+        fileUniqueId: raw.document.file_unique_id
+      }));
+    }
+    if (raw.video_note) {
+      attachments.push(this.createAttachment("video", raw.video_note.file_id, {
+        size: raw.video_note.file_size,
+        width: raw.video_note.length,
+        height: raw.video_note.length,
+        fileUniqueId: raw.video_note.file_unique_id
+      }));
+    }
+    if (raw.animation) {
+      attachments.push(this.createAttachment("video", raw.animation.file_id, {
+        size: raw.animation.file_size,
+        width: raw.animation.width,
+        height: raw.animation.height,
+        name: raw.animation.file_name,
+        mimeType: raw.animation.mime_type,
+        fileUniqueId: raw.animation.file_unique_id
+      }));
+    }
+    if (raw.sticker) {
+      const format = stickerAttachmentFormat(raw.sticker);
+      attachments.push(this.createAttachment(format.type, raw.sticker.file_id, {
+        size: raw.sticker.file_size,
+        width: raw.sticker.width,
+        height: raw.sticker.height,
+        mimeType: format.mimeType,
+        fileUniqueId: raw.sticker.file_unique_id
+      }));
+    }
+    if (raw.rich_message) {
+      for (const media2 of richMessageMedia(raw.rich_message)) {
+        attachments.push(this.createAttachment(media2.type, media2.file.file_id, {
+          size: media2.file.file_size,
+          width: media2.width,
+          height: media2.height,
+          name: media2.name,
+          mimeType: media2.mimeType,
+          fileUniqueId: media2.file.file_unique_id
+        }));
+      }
+    }
+    return attachments;
+  }
+  createAttachment(type, fileId, metadata) {
+    return {
+      type,
+      size: metadata?.size,
+      width: metadata?.width,
+      height: metadata?.height,
+      name: metadata?.name,
+      mimeType: metadata?.mimeType,
+      fetchMetadata: {
+        fileId,
+        ...metadata?.fileUniqueId ? { fileUniqueId: metadata.fileUniqueId } : {}
+      },
+      fetchData: async () => this.downloadFile(fileId)
+    };
+  }
+  rehydrateAttachment(attachment) {
+    const fileId = attachment.fetchMetadata?.fileId;
+    if (!fileId) {
+      return attachment;
+    }
+    return {
+      ...attachment,
+      fetchData: async () => this.downloadFile(fileId)
+    };
+  }
+  async downloadFile(fileId) {
+    const file = await this.telegramFetch("getFile", {
+      file_id: fileId
+    });
+    if (!file.file_path) {
+      throw new ResourceNotFoundError("telegram", "file", fileId);
+    }
+    const botToken = this.staticBotToken ?? await this.resolveBotToken();
+    const fileUrl = `${this.apiBaseUrl}/file/bot${botToken}/${file.file_path}`;
+    let response;
+    try {
+      response = await fetch(fileUrl, {
+        signal: AbortSignal.timeout(TELEGRAM_FILE_TIMEOUT_MS)
+      });
+    } catch (error) {
+      throw new NetworkError("telegram", `Failed to download Telegram file ${fileId}`, error instanceof Error ? error : undefined);
+    }
+    if (!response.ok) {
+      throw new NetworkError("telegram", `Failed to download Telegram file ${fileId}: ${response.status}`);
+    }
+    try {
+      return await readTelegramFile(response, fileId);
+    } catch (error) {
+      if (error instanceof NetworkError) {
+        throw error;
+      }
+      throw new NetworkError("telegram", `Failed to download Telegram file ${fileId}`, error instanceof Error ? error : undefined);
+    }
+  }
+  async sendDocument(thread, file, text2, plainText, replyMarkup, parseMode = "plain", replyParameters) {
+    const buffer = await this.toTelegramBuffer(file.data);
+    return this.withTelegramMarkdownFallback(parseMode, (resolvedParseMode, resolvedText) => this.telegramFetch("sendDocument", this.createTelegramDocumentFormData(thread, file, buffer, resolvedText, replyMarkup, resolvedParseMode, replyParameters)), {
+      initialText: text2,
+      fallbackText: plainText,
+      method: "sendDocument",
+      threadId: this.encodeThreadId(thread)
+    });
+  }
+  createTelegramDocumentFormData(thread, file, buffer, text2, replyMarkup, parseMode = "plain", replyParameters) {
+    const formData = new FormData;
+    this.appendChatTargetToFormData(formData, thread);
+    this.appendReplyParameters(formData, replyParameters);
+    if (text2.trim()) {
+      formData.append("caption", truncateForTelegram(text2, TELEGRAM_CAPTION_LIMIT, parseMode));
+      const botApiParseMode = toBotApiParseMode(parseMode);
+      if (botApiParseMode) {
+        formData.append("parse_mode", botApiParseMode);
+      }
+    }
+    const blob = new Blob([new Uint8Array(buffer)], {
+      type: file.mimeType ?? "application/octet-stream"
+    });
+    formData.append("document", blob, file.filename);
+    if (replyMarkup) {
+      formData.append("reply_markup", JSON.stringify(replyMarkup));
+    }
+    return formData;
+  }
+  async sendAttachment(thread, attachment, text2, plainText, replyMarkup, parseMode = "plain", replyParameters) {
+    const upload = ATTACHMENT_UPLOADS[attachment.type];
+    const data = attachment.data ?? (attachment.fetchData ? await attachment.fetchData() : undefined);
+    if (!(data || attachment.url)) {
+      throw new ValidationError("telegram", `Attachment data or URL required for ${attachment.type}`);
+    }
+    const buffer = data ? await this.toTelegramBuffer(data) : undefined;
+    return this.withTelegramMarkdownFallback(parseMode, (resolvedParseMode, resolvedText) => {
+      if (!buffer) {
+        const payload = {
+          ...this.buildChatTargetParams(thread),
+          [upload.field]: attachment.url,
+          reply_parameters: replyParameters
+        };
+        if (resolvedText.trim()) {
+          payload.caption = truncateForTelegram(resolvedText, TELEGRAM_CAPTION_LIMIT, resolvedParseMode);
+          const botApiParseMode = toBotApiParseMode(resolvedParseMode);
+          if (botApiParseMode) {
+            payload.parse_mode = botApiParseMode;
+          }
+        }
+        if (attachment.type === "video") {
+          if (Number.isInteger(attachment.width)) {
+            payload.width = attachment.width;
+          }
+          if (Number.isInteger(attachment.height)) {
+            payload.height = attachment.height;
+          }
+        }
+        if (replyMarkup) {
+          payload.reply_markup = replyMarkup;
+        }
+        return this.telegramFetch(upload.method, payload);
+      }
+      const formData = new FormData;
+      this.appendChatTargetToFormData(formData, thread);
+      if (resolvedText.trim()) {
+        formData.append("caption", truncateForTelegram(resolvedText, TELEGRAM_CAPTION_LIMIT, resolvedParseMode));
+        const botApiParseMode = toBotApiParseMode(resolvedParseMode);
+        if (botApiParseMode) {
+          formData.append("parse_mode", botApiParseMode);
+        }
+      }
+      if (attachment.type === "video") {
+        if (Number.isInteger(attachment.width)) {
+          formData.append("width", String(attachment.width));
+        }
+        if (Number.isInteger(attachment.height)) {
+          formData.append("height", String(attachment.height));
+        }
+      }
+      const blob = new Blob([new Uint8Array(buffer)], {
+        type: attachment.mimeType ?? "application/octet-stream"
+      });
+      formData.append(upload.field, blob, attachment.name ?? "attachment");
+      if (replyMarkup) {
+        formData.append("reply_markup", JSON.stringify(replyMarkup));
+      }
+      this.appendReplyParameters(formData, replyParameters);
+      return this.telegramFetch(upload.method, formData);
+    }, {
+      initialText: text2,
+      fallbackText: plainText,
+      method: upload.method,
+      threadId: this.encodeThreadId(thread)
+    });
+  }
+  async sendDocumentMediaGroup(thread, files, text2, plainText, replyMarkup, parseMode = "plain", replyParameters) {
+    this.validateMediaGroupLength(files.length);
+    if (replyMarkup) {
+      throw new ValidationError("telegram", "Telegram media groups do not support inline keyboards");
+    }
+    const parts = [];
+    for (const [index, file] of files.entries()) {
+      parts.push({
+        buffer: await this.toTelegramBuffer(file.data),
+        filename: file.filename,
+        media: `attach://media${index}`,
+        mimeType: file.mimeType,
+        type: "document"
+      });
+    }
+    return this.withTelegramMarkdownFallback(parseMode, (resolvedParseMode, resolvedText) => this.telegramFetch("sendMediaGroup", this.createTelegramMediaGroupFormData(thread, parts, resolvedText, resolvedParseMode, replyParameters)), {
+      initialText: text2,
+      fallbackText: plainText,
+      method: "sendMediaGroup",
+      threadId: this.encodeThreadId(thread)
+    });
+  }
+  async sendAttachmentMediaGroup(thread, attachments, text2, plainText, replyMarkup, parseMode = "plain", replyParameters) {
+    this.validateMediaGroupLength(attachments.length);
+    this.validateAttachmentMediaGroupTypes(attachments);
+    if (replyMarkup) {
+      throw new ValidationError("telegram", "Telegram media groups do not support inline keyboards");
+    }
+    const parts = [];
+    for (const [index, attachment] of attachments.entries()) {
+      const data = attachment.data ?? (attachment.fetchData ? await attachment.fetchData() : undefined);
+      if (!(data || attachment.url)) {
+        throw new ValidationError("telegram", `Attachment data or URL required for ${attachment.type}`);
+      }
+      const buffer = data ? await this.toTelegramBuffer(data) : undefined;
+      const media2 = buffer ? `attach://media${index}` : attachment.url;
+      if (!media2) {
+        throw new ValidationError("telegram", `Attachment data or URL required for ${attachment.type}`);
+      }
+      parts.push({
+        buffer,
+        filename: attachment.name ?? `attachment-${index}`,
+        height: attachment.height,
+        media: media2,
+        mimeType: attachment.mimeType,
+        type: ATTACHMENT_MEDIA_GROUP_TYPES[attachment.type],
+        width: attachment.width
+      });
+    }
+    return this.withTelegramMarkdownFallback(parseMode, (resolvedParseMode, resolvedText) => this.telegramFetch("sendMediaGroup", this.createTelegramMediaGroupFormData(thread, parts, resolvedText, resolvedParseMode, replyParameters)), {
+      initialText: text2,
+      fallbackText: plainText,
+      method: "sendMediaGroup",
+      threadId: this.encodeThreadId(thread)
+    });
+  }
+  createTelegramMediaGroupFormData(thread, parts, text2, parseMode, replyParameters) {
+    const formData = new FormData;
+    this.appendChatTargetToFormData(formData, thread);
+    this.appendReplyParameters(formData, replyParameters);
+    const captionIndex = 0;
+    const botApiParseMode = toBotApiParseMode(parseMode);
+    const media2 = parts.map((part, index) => {
+      const item2 = {
+        media: part.media,
+        type: part.type
+      };
+      if (index === captionIndex && text2.trim()) {
+        item2.caption = truncateForTelegram(text2, TELEGRAM_CAPTION_LIMIT, parseMode);
+        if (botApiParseMode) {
+          item2.parse_mode = botApiParseMode;
+        }
+      }
+      if (part.type === "video") {
+        if (Number.isInteger(part.width)) {
+          item2.width = part.width;
+        }
+        if (Number.isInteger(part.height)) {
+          item2.height = part.height;
+        }
+      }
+      return item2;
+    });
+    formData.append("media", JSON.stringify(media2));
+    for (const [index, part] of parts.entries()) {
+      if (!part.buffer) {
+        continue;
+      }
+      const blob = new Blob([new Uint8Array(part.buffer)], {
+        type: part.mimeType ?? "application/octet-stream"
+      });
+      formData.append(`media${index}`, blob, part.filename ?? `media-${index}`);
+    }
+    return formData;
+  }
+  validateMediaGroupLength(count) {
+    if (count < TELEGRAM_MEDIA_GROUP_MIN || count > TELEGRAM_MEDIA_GROUP_MAX) {
+      throw new ValidationError("telegram", "Telegram media groups support 2-10 files");
+    }
+  }
+  validateAttachmentMediaGroupTypes(attachments) {
+    const categories = new Set(attachments.map((attachment) => {
+      if (attachment.type === "file") {
+        return "document";
+      }
+      if (attachment.type === "audio") {
+        return "audio";
+      }
+      return "visual";
+    }));
+    if (categories.size > 1) {
+      throw new ValidationError("telegram", "Telegram media groups can mix photos and videos, but documents and audio files must be grouped only with the same type");
+    }
+  }
+  async toTelegramBuffer(data) {
+    if (Buffer.isBuffer(data)) {
+      return data;
+    }
+    if (data instanceof ArrayBuffer) {
+      return Buffer.from(data);
+    }
+    if (data instanceof Blob) {
+      return Buffer.from(await data.arrayBuffer());
+    }
+    throw new ValidationError("telegram", "Unsupported file data type");
+  }
+  paginateMessages(messages, options) {
+    const limit = Math.max(1, Math.min(options.limit ?? 50, 100));
+    const direction = options.direction ?? "backward";
+    if (messages.length === 0) {
+      return { messages: [] };
+    }
+    const messageIndexById = new Map(messages.map((message, index) => [message.id, index]));
+    if (direction === "backward") {
+      const end2 = options.cursor && messageIndexById.has(options.cursor) ? messageIndexById.get(options.cursor) ?? messages.length : messages.length;
+      const start2 = Math.max(0, end2 - limit);
+      const page2 = messages.slice(start2, end2);
+      return {
+        messages: page2,
+        nextCursor: start2 > 0 ? page2[0]?.id : undefined
+      };
+    }
+    const start = options.cursor && messageIndexById.has(options.cursor) ? (messageIndexById.get(options.cursor) ?? -1) + 1 : 0;
+    const end = Math.min(messages.length, start + limit);
+    const page = messages.slice(start, end);
+    return {
+      messages: page,
+      nextCursor: end < messages.length ? page.at(-1)?.id : undefined
+    };
+  }
+  cacheMessage(message) {
+    const existing = this.messageCache.get(message.threadId) ?? [];
+    const index = existing.findIndex((item2) => item2.id === message.id);
+    if (index >= 0) {
+      existing[index] = message;
+    } else {
+      existing.push(message);
+    }
+    existing.sort((a, b) => this.compareMessages(a, b));
+    this.messageCache.set(message.threadId, existing);
+  }
+  findCachedMessage(messageId) {
+    for (const messages of this.messageCache.values()) {
+      const found = messages.find((message) => message.id === messageId);
+      if (found) {
+        return found;
+      }
+    }
+    return;
+  }
+  deleteCachedMessage(messageId) {
+    for (const [threadId, messages] of this.messageCache.entries()) {
+      const filtered = messages.filter((message) => message.id !== messageId);
+      if (filtered.length === 0) {
+        this.messageCache.delete(threadId);
+      } else if (filtered.length !== messages.length) {
+        this.messageCache.set(threadId, filtered);
+      }
+    }
+  }
+  compareMessages(a, b) {
+    const timeDiff = a.metadata.dateSent.getTime() - b.metadata.dateSent.getTime();
+    if (timeDiff !== 0) {
+      return timeDiff;
+    }
+    return this.messageSequence(a.id) - this.messageSequence(b.id);
+  }
+  messageSequence(messageId) {
+    const match = messageId.match(MESSAGE_SEQUENCE_PATTERN);
+    return match ? Number.parseInt(match[1], 10) : 0;
+  }
+  createDraftId() {
+    this.nextDraftId = this.nextDraftId >= 2147483647 ? 1 : this.nextDraftId + 1;
+    return this.nextDraftId;
+  }
+  resolveThreadId(value) {
+    if (value.startsWith("telegram:")) {
+      return this.decodeThreadId(value);
+    }
+    return { chatId: value };
+  }
+  buildChatTargetParams(thread) {
+    const params = {
+      chat_id: thread.chatId
+    };
+    if (typeof thread.messageThreadId === "number") {
+      params.message_thread_id = thread.messageThreadId;
+    }
+    if (thread.businessConnectionId) {
+      params.business_connection_id = thread.businessConnectionId;
+    }
+    return params;
+  }
+  appendChatTargetToFormData(formData, thread) {
+    formData.append("chat_id", thread.chatId);
+    if (typeof thread.messageThreadId === "number") {
+      formData.append("message_thread_id", String(thread.messageThreadId));
+    }
+    if (thread.businessConnectionId) {
+      formData.append("business_connection_id", thread.businessConnectionId);
+    }
+  }
+  encodeMessageId(chatId, messageId) {
+    return `${chatId}:${messageId}`;
+  }
+  buildReplyParameters(replyToMessageId, expectedChatId) {
+    if (!replyToMessageId) {
+      return;
+    }
+    const { messageId } = this.decodeCompositeMessageId(replyToMessageId, expectedChatId);
+    return { message_id: messageId, allow_sending_without_reply: true };
+  }
+  appendReplyParameters(formData, replyParameters) {
+    if (replyParameters) {
+      formData.append("reply_parameters", JSON.stringify(replyParameters));
+    }
+  }
+  decodeCompositeMessageId(messageId, expectedChatId) {
+    const compositeMatch = messageId.match(MESSAGE_ID_PATTERN);
+    if (compositeMatch) {
+      const [, chatId, rawMessageId] = compositeMatch;
+      const parsedMessageId2 = Number.parseInt(rawMessageId, 10);
+      if (expectedChatId && chatId !== expectedChatId) {
+        throw new ValidationError("telegram", `Message ID chat mismatch: expected ${expectedChatId}, got ${chatId}`);
+      }
+      return {
+        chatId,
+        messageId: parsedMessageId2,
+        compositeId: `${chatId}:${parsedMessageId2}`
+      };
+    }
+    if (!expectedChatId) {
+      throw new ValidationError("telegram", `Telegram message ID must be in <chatId>:<messageId> format, got: ${messageId}`);
+    }
+    if (!BARE_MESSAGE_ID_PATTERN.test(messageId)) {
+      throw new ValidationError("telegram", `Invalid Telegram message ID: ${messageId}`);
+    }
+    const parsedMessageId = Number.parseInt(messageId, 10);
+    return {
+      chatId: expectedChatId,
+      messageId: parsedMessageId,
+      compositeId: `${expectedChatId}:${parsedMessageId}`
+    };
+  }
+  toAuthor(user) {
+    const fullName = [user.first_name, user.last_name].filter(Boolean).join(" ").trim();
+    return {
+      userId: String(user.id),
+      userName: user.username ?? user.first_name ?? String(user.id),
+      fullName: fullName || user.username || String(user.id),
+      isBot: user.is_bot,
+      isMe: String(user.id) === this._botUserId
+    };
+  }
+  toReactionActorAuthor(chat) {
+    const name = this.chatDisplayName(chat) ?? String(chat.id);
+    return {
+      userId: `chat:${chat.id}`,
+      userName: name,
+      fullName: name,
+      isBot: "unknown",
+      isMe: false
+    };
+  }
+  chatDisplayName(chat) {
+    if (chat.title) {
+      return chat.title;
+    }
+    const privateName = [chat.first_name, chat.last_name].filter(Boolean).join(" ").trim();
+    if (privateName) {
+      return privateName;
+    }
+    return chat.username;
+  }
+  isBotMentioned(message, text2) {
+    if (this.mentionOnReply && this._botUserId && message.reply_to_message?.from && String(message.reply_to_message.from.id) === this._botUserId && message.reply_to_message.message_id !== message.message_thread_id && !(message.from && String(message.from.id) === this._botUserId)) {
+      return true;
+    }
+    if (!text2) {
+      return false;
+    }
+    const username = this._userName;
+    const entities = message.entities ?? message.caption_entities ?? [];
+    for (const entity of entities) {
+      if (entity.type === "mention") {
+        const mentionText = this.entityText(text2, entity);
+        if (mentionText.toLowerCase() === `@${username.toLowerCase()}`) {
+          return true;
+        }
+      }
+      if (entity.type === "text_mention" && entity.user && this._botUserId && String(entity.user.id) === this._botUserId) {
+        return true;
+      }
+      if (entity.type === "bot_command") {
+        const commandText = this.entityText(text2, entity);
+        if (commandText.toLowerCase().endsWith(`@${username.toLowerCase()}`)) {
+          return true;
+        }
+      }
+    }
+    const mentionRegex = this.getMentionRegex(username);
+    return mentionRegex.test(text2);
+  }
+  getMentionRegex(username) {
+    if (!this._mentionRegex || this._mentionRegexUsername !== username) {
+      this._mentionRegexUsername = username;
+      this._mentionRegex = new RegExp(`@${this.escapeRegex(username)}(?![\\w-])`, "i");
+    }
+    return this._mentionRegex;
+  }
+  entityText(text2, entity) {
+    return text2.slice(entity.offset, entity.offset + entity.length);
+  }
+  escapeRegex(input) {
+    return input.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  }
+  normalizeUserName(value) {
+    if (typeof value !== "string") {
+      return "bot";
+    }
+    return value.replace(LEADING_AT_PATTERN, "").trim() || "bot";
+  }
+  resolveParseMode(message, card) {
+    if (card) {
+      return "MarkdownV2";
+    }
+    if (typeof message === "string") {
+      return "plain";
+    }
+    if (typeof message === "object" && message !== null && "raw" in message) {
+      return "plain";
+    }
+    return "MarkdownV2";
+  }
+  resolveRichMessage(message, card, fileCount, attachmentCount) {
+    if (!this.richMessagesAvailable || card || fileCount > 0 || attachmentCount > 0 || typeof message === "string" || "raw" in message) {
+      return null;
+    }
+    if ("markdown" in message) {
+      const formatted = this.formatConverter.toAst(message.markdown);
+      return {
+        formatted,
+        markdown: truncateRichMarkdown(convertEmojiPlaceholders(message.markdown, "gchat")),
+        text: toPlainText(formatted)
+      };
+    }
+    if ("ast" in message) {
+      return {
+        formatted: message.ast,
+        markdown: truncateRichMarkdown(convertEmojiPlaceholders(stringifyMarkdown(message.ast), "gchat")),
+        text: toPlainText(message.ast)
+      };
+    }
+    return null;
+  }
+  renderPlainTextMessage(message, card) {
+    if (card) {
+      return cardToFallbackText(card);
+    }
+    if (typeof message === "string") {
+      return message;
+    }
+    if ("raw" in message) {
+      return message.raw;
+    }
+    if ("markdown" in message) {
+      return this.resolveTelegramFallbackText(message.markdown, markdownToPlainText(message.markdown));
+    }
+    if ("ast" in message) {
+      return toPlainText(message.ast);
+    }
+    return this.formatConverter.renderPostable(message);
+  }
+  resolveTelegramFallbackText(originalText, fallbackText) {
+    return fallbackText.trim() ? fallbackText : originalText;
+  }
+  async sendRegularMessage(thread, text2, plainText, parseMode, replyMarkup, threadId, replyParameters) {
+    return this.withTelegramMarkdownFallback(parseMode, (resolvedParseMode, resolvedText) => this.telegramFetch("sendMessage", {
+      ...this.buildChatTargetParams(thread),
+      text: resolvedText,
+      reply_markup: replyMarkup,
+      parse_mode: toBotApiParseMode(resolvedParseMode),
+      reply_parameters: replyParameters
+    }), {
+      initialText: text2,
+      fallbackText: plainText,
+      method: "sendMessage",
+      threadId
+    });
+  }
+  canFallbackFromRichMessage(error, method) {
+    const message = error instanceof ValidationError ? error.message.toLowerCase() : "";
+    const missingMethod = message.includes("method") && message.includes("not found");
+    const unsupportedRich = message.includes("rich message") && message.includes("unsupported");
+    const rejectedReplyParameters = message.includes("reply_parameters");
+    return method.startsWith("sendRichMessage") && error instanceof ResourceNotFoundError || error instanceof ValidationError && (message.includes("can't parse") || missingMethod || unsupportedRich || rejectedReplyParameters);
+  }
+  rememberRichMessageFailure(error, method) {
+    const message = error instanceof ValidationError ? error.message.toLowerCase() : "";
+    const missingMethod = message.includes("method") && message.includes("not found");
+    const unsupportedRich = message.includes("rich message") && message.includes("unsupported");
+    if (method.startsWith("sendRichMessage") && error instanceof ResourceNotFoundError || error instanceof ValidationError && (missingMethod || unsupportedRich)) {
+      this.richMessagesAvailable = false;
+    }
+  }
+  toTelegramReaction(emoji) {
+    if (typeof emoji !== "string") {
+      return {
+        type: "emoji",
+        emoji: defaultEmojiResolver.toGChat(emoji.name)
+      };
+    }
+    if (emoji.startsWith("custom:")) {
+      return {
+        type: "custom_emoji",
+        custom_emoji_id: emoji.slice("custom:".length)
+      };
+    }
+    const placeholderMatch = emoji.match(EMOJI_PLACEHOLDER_PATTERN);
+    if (placeholderMatch) {
+      return {
+        type: "emoji",
+        emoji: defaultEmojiResolver.toGChat(placeholderMatch[1])
+      };
+    }
+    if (EMOJI_NAME_PATTERN.test(emoji)) {
+      return {
+        type: "emoji",
+        emoji: defaultEmojiResolver.toGChat(emoji.toLowerCase())
+      };
+    }
+    return {
+      type: "emoji",
+      emoji
+    };
+  }
+  reactionKey(reaction) {
+    if (reaction.type === "emoji") {
+      return reaction.emoji;
+    }
+    return `custom:${reaction.custom_emoji_id}`;
+  }
+  reactionToEmojiValue(reaction) {
+    if (reaction.type === "emoji") {
+      return defaultEmojiResolver.fromGChat(reaction.emoji);
+    }
+    return getEmoji(`custom:${reaction.custom_emoji_id}`);
+  }
+  pollingGroup(update) {
+    const message = update.message ?? update.edited_message ?? update.channel_post ?? update.edited_channel_post ?? update.business_message ?? update.edited_business_message;
+    if (this.allowedUserIds && (message?.from === undefined || !this.allowedUserIds.has(String(message.from.id)))) {
+      return;
+    }
+    return message?.media_group_id ? JSON.stringify([
+      message.chat.id,
+      message.message_thread_id,
+      message.business_connection_id,
+      message.media_group_id
+    ]) : undefined;
+  }
+  async processPollingUpdates(updates, completed) {
+    const groups = /* @__PURE__ */ new Map;
+    for (const update of updates) {
+      const key = this.pollingGroup(update) ?? String(update.update_id);
+      const group = groups.get(key) ?? [];
+      group.push(update);
+      groups.set(key, group);
+    }
+    const pending = [...groups.values()].map(async (group) => {
+      try {
+        const results = await Promise.allSettled(group.map(async (update) => {
+          if (!completed.has(update.update_id)) {
+            const tasks = await Promise.allSettled(this.processUpdate(update, { deduplicate: false }) ?? []);
+            for (const task of tasks) {
+              if (task.status === "rejected") {
+                throw task.reason;
+              }
+            }
+          }
+        }));
+        for (const result of results) {
+          if (result.status === "rejected") {
+            throw result.reason;
+          }
+        }
+        return group.map((update) => {
+          completed.add(update.update_id);
+          return { update };
+        });
+      } catch (error) {
+        return group.map((update) => ({ error, update }));
+      }
+    });
+    return (await Promise.all(pending)).flat().sort((left, right) => left.update.update_id - right.update.update_id);
+  }
+  async pollingLoop(config) {
+    const state = this.chat?.getState();
+    if (!state) {
+      return;
+    }
+    let checkpoint;
+    let consecutiveFailures = 0;
+    let drained = false;
+    const MAX_BACKOFF_MS = 30000;
+    const completed = /* @__PURE__ */ new Set;
+    const retry = (entries, error) => {
+      const attempts = Math.max(...entries.map((entry) => entry.attempts ?? 0)) + 1;
+      const delay = Math.max(Math.min(Math.max(config.retryDelayMs, TELEGRAM_DEFAULT_POLLING_RETRY_DELAY_MS) * 2 ** Math.min(attempts - 1, 30), MAX_BACKOFF_MS), error instanceof AdapterRateLimitError ? (error.retryAfter ?? 0) * 1000 : 0);
+      const retryAt = Date.now() + delay;
+      this.logger.warn("Telegram polling update processing failed", {
+        error: String(error),
+        updateId: entries[0].update.update_id,
+        attempts,
+        retryAt
+      });
+      return { attempts, retryAt };
+    };
+    while (this.pollingActive) {
+      this.pollingAbortController = new AbortController;
+      let timer;
+      try {
+        await this.ensureBotIdentity();
+        const key = `${this.name}:polling:${this.webhookScope}`;
+        checkpoint ??= await state.get(key) ?? {
+          pending: []
+        };
+        const groups = /* @__PURE__ */ new Map;
+        for (const entry of checkpoint.pending) {
+          const group = this.pollingGroup(entry.update) ?? String(entry.update.update_id);
+          const entries = groups.get(group) ?? [];
+          entries.push(entry);
+          groups.set(group, entries);
+        }
+        const eligible = [...groups.values()].filter((entries) => entries.every((entry) => entry.update.update_id < (checkpoint?.offset ?? 0)));
+        const deadline = (entries) => Math.max(...entries.map((entry) => Math.max(entry.receivedAt + (this.pollingGroup(entry.update) ? TELEGRAM_INCOMING_MEDIA_GROUP_SETTLE_MS : 0), entry.retryAt ?? 0)));
+        const ready = eligible.filter((entries) => deadline(entries) <= Date.now());
+        if (ready.length > 0 && !drained) {
+          const results2 = await this.processPollingUpdates(ready.flatMap((entries) => entries.map((entry) => entry.update)), completed);
+          const failures = new Map(results2.flatMap((result) => ("error" in result) ? [[result.update.update_id, result.error]] : []));
+          const retries = /* @__PURE__ */ new Map;
+          for (const entries of ready) {
+            const failed = entries.find((entry) => failures.has(entry.update.update_id));
+            if (!failed) {
+              continue;
+            }
+            const scheduled = retry(entries, failures.get(failed.update.update_id));
+            for (const entry of entries) {
+              retries.set(entry.update.update_id, scheduled);
+            }
+          }
+          const pending2 = checkpoint.pending.filter((entry) => !completed.has(entry.update.update_id)).map((entry) => ({
+            ...entry,
+            ...retries.get(entry.update.update_id)
+          }));
+          const next2 = { ...checkpoint, pending: pending2 };
+          if (pending2.length > 0) {
+            await state.set(key, next2);
+          } else {
+            await state.delete(key);
+          }
+          checkpoint = next2;
+          for (const result of results2) {
+            completed.delete(result.update.update_id);
+          }
+          consecutiveFailures = 0;
+          drained = true;
+          continue;
+        }
+        const remaining = eligible.length > 0 ? Math.max(0, Math.min(...eligible.map(deadline)) - Date.now()) : undefined;
+        let collecting = false;
+        if (remaining !== undefined && remaining > 0) {
+          timer = setTimeout(() => {
+            collecting = true;
+            this.pollingAbortController?.abort();
+          }, remaining);
+        }
+        let updates;
+        try {
+          updates = await this.telegramFetch("getUpdates", {
+            allowed_updates: config.allowedUpdates,
+            limit: config.limit,
+            offset: checkpoint.offset,
+            timeout: remaining === 0 ? 0 : config.timeout
+          }, { signal: this.pollingAbortController.signal });
+        } catch (error) {
+          if (collecting && this.pollingActive && this.isAbortError(error)) {
+            updates = [];
+          } else {
+            throw error;
+          }
+        } finally {
+          clearTimeout(timer);
+        }
+        drained = false;
+        if (!this.pollingActive) {
+          return;
+        }
+        const results = await this.processPollingUpdates(updates.filter((update) => !this.pollingGroup(update)), completed);
+        const pending = new Map(checkpoint.pending.map((entry) => [entry.update.update_id, entry]));
+        for (const result of results) {
+          if ("error" in result) {
+            const entry = { update: result.update, receivedAt: Date.now() };
+            pending.set(result.update.update_id, {
+              ...entry,
+              ...retry([entry], result.error)
+            });
+          }
+        }
+        for (const update of updates) {
+          if (this.pollingGroup(update) && !completed.has(update.update_id) && !pending.has(update.update_id)) {
+            pending.set(update.update_id, { update, receivedAt: Date.now() });
+          }
+        }
+        let offset = checkpoint.offset;
+        for (const update of updates) {
+          offset = update.update_id + 1;
+        }
+        const next = { offset, pending: [...pending.values()] };
+        if (next.pending.length > 0 || checkpoint.pending.length > 0) {
+          await state.set(key, next);
+        }
+        checkpoint = next;
+        for (const id of completed) {
+          if (id < (offset ?? 0)) {
+            completed.delete(id);
+          }
+        }
+        if (updates.length === 0 && remaining !== undefined) {
+          await this.sleep(Math.min(remaining, TELEGRAM_INCOMING_MEDIA_GROUP_RETRY_MS), this.pollingAbortController.signal);
+        }
+        consecutiveFailures = 0;
+      } catch (error) {
+        if (this.isAbortError(error) && !this.pollingActive) {
+          return;
+        }
+        consecutiveFailures++;
+        const backoffMs = Math.min(config.retryDelayMs * 2 ** (consecutiveFailures - 1), MAX_BACKOFF_MS);
+        this.logger.warn("Telegram polling request failed", {
+          error: String(error),
+          retryDelayMs: backoffMs,
+          consecutiveFailures
+        });
+        if (!this.pollingActive) {
+          return;
+        }
+        await this.sleep(backoffMs, this.pollingAbortController?.signal);
+      } finally {
+        clearTimeout(timer);
+        this.pollingAbortController = null;
+      }
+    }
+  }
+  resolvePollingConfig(override) {
+    const baseConfig = this.longPolling ?? {};
+    const merged = {
+      ...baseConfig,
+      ...override
+    };
+    return {
+      allowedUpdates: this.resolveAllowedUpdates(merged.allowedUpdates),
+      deleteWebhook: merged.deleteWebhook ?? true,
+      dropPendingUpdates: merged.dropPendingUpdates ?? false,
+      limit: this.clampInteger(merged.limit, TELEGRAM_DEFAULT_POLLING_LIMIT, TELEGRAM_MIN_POLLING_LIMIT, TELEGRAM_MAX_POLLING_LIMIT),
+      retryDelayMs: this.clampInteger(merged.retryDelayMs, TELEGRAM_DEFAULT_POLLING_RETRY_DELAY_MS, 0, Number.MAX_SAFE_INTEGER),
+      timeout: this.clampInteger(merged.timeout, TELEGRAM_DEFAULT_POLLING_TIMEOUT_SECONDS, TELEGRAM_MIN_POLLING_TIMEOUT_SECONDS, TELEGRAM_MAX_POLLING_TIMEOUT_SECONDS)
+    };
+  }
+  resolveAllowedUpdates(allowedUpdates) {
+    if (!this.businessMode) {
+      return allowedUpdates && allowedUpdates.length > 0 ? [...allowedUpdates] : undefined;
+    }
+    const base = allowedUpdates && allowedUpdates.length > 0 ? allowedUpdates : TELEGRAM_DEFAULT_ALLOWED_UPDATES;
+    return [.../* @__PURE__ */ new Set([...base, ...TELEGRAM_BUSINESS_ALLOWED_UPDATES])];
+  }
+  clampInteger(value, fallback, min, max) {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+      return fallback;
+    }
+    const parsed = Math.trunc(value);
+    return Math.max(min, Math.min(max, parsed));
+  }
+  isAbortError(error) {
+    return error instanceof Error && error.name === "AbortError";
+  }
+  async sleep(delayMs, signal) {
+    if (delayMs <= 0 || signal?.aborted) {
+      return;
+    }
+    await new Promise((resolve) => {
+      const timeoutId = setTimeout(() => {
+        signal?.removeEventListener("abort", onAbort);
+        resolve();
+      }, delayMs);
+      const onAbort = () => {
+        clearTimeout(timeoutId);
+        signal?.removeEventListener("abort", onAbort);
+        resolve();
+      };
+      signal?.addEventListener("abort", onAbort, { once: true });
+    });
+  }
+  async telegramFetch(method, payload, request) {
+    const botToken = this.staticBotToken ?? await this.resolveBotToken();
+    const url = `${this.apiBaseUrl}/bot${botToken}/${method}`;
+    let response;
+    try {
+      response = await fetch(url, {
+        method: "POST",
+        headers: payload instanceof FormData ? undefined : {
+          "Content-Type": "application/json"
+        },
+        body: payload instanceof FormData ? payload : JSON.stringify(payload ?? {}),
+        signal: request?.signal
+      });
+    } catch (error) {
+      if (this.isAbortError(error)) {
+        throw error;
+      }
+      throw new NetworkError("telegram", `Network error calling Telegram ${method}`, error instanceof Error ? error : undefined);
+    }
+    let data;
+    try {
+      data = await response.json();
+    } catch {
+      throw new NetworkError("telegram", `Failed to parse Telegram API response for ${method}`);
+    }
+    if (!(response.ok && data.ok)) {
+      this.throwTelegramApiError(method, response.status, data);
+    }
+    if (typeof data.result === "undefined") {
+      throw new NetworkError("telegram", `Telegram API ${method} returned no result`);
+    }
+    return data.result;
+  }
+  throwTelegramApiError(method, status, data) {
+    const errorCode = data.error_code ?? status;
+    const description = data.description ?? `Telegram API ${method} failed`;
+    if (errorCode === 429) {
+      throw new AdapterRateLimitError("telegram", data.parameters?.retry_after);
+    }
+    if (errorCode === 401) {
+      throw new AuthenticationError("telegram", description);
+    }
+    if (errorCode === 403) {
+      throw new PermissionError("telegram", method);
+    }
+    if (errorCode === 404) {
+      throw new ResourceNotFoundError("telegram", method);
+    }
+    if (errorCode >= 400 && errorCode < 500) {
+      throw new ValidationError("telegram", description);
+    }
+    throw new NetworkError("telegram", `${description} (status ${status}, error ${errorCode})`);
+  }
+  async withTelegramMarkdownFallback(parseMode, operation, context) {
+    try {
+      return await operation(parseMode, context.initialText);
+    } catch (error) {
+      if (parseMode !== "MarkdownV2" || !this.isTelegramMarkdownParseError(error)) {
+        throw error;
+      }
+      this.logger.warn("Telegram markdown parse failed; retrying without parse mode", {
+        error: String(error),
+        ...context
+      });
+      return operation("plain", this.resolveTelegramFallbackText(context.initialText, context.fallbackText));
+    }
+  }
+  isTelegramMarkdownParseError(error) {
+    return error instanceof ValidationError && error.adapter === "telegram" && TELEGRAM_MARKDOWN_PARSE_ERROR_PATTERN.test(error.message);
+  }
+  async withTelegramRichFallback(operation, fallback, context) {
+    try {
+      return await operation();
+    } catch (error) {
+      if (!this.canFallbackFromRichMessage(error, context.method)) {
+        throw error;
+      }
+      this.rememberRichMessageFailure(error, context.method);
+      this.logger.warn("Telegram rich message failed; retrying with a regular message", {
+        error: String(error),
+        ...context
+      });
+      return fallback();
+    }
+  }
+};
+function createTelegramAdapter(config) {
+  return new TelegramAdapter(config ?? {});
+}
+export {
+  TelegramAdapter,
+  TelegramFormatConverter,
+  applyTelegramEntities,
+  createTelegramAdapter,
+  escapeMarkdownV2
+};