@qwen-code/qwen-code 0.22.2 → 0.22.3-nightly.20260831.3a0c4c6108

package/chunks/{dist-QODVOVWI.js → dist-GPSRNVVP.js}

@@ -11,11 +11,11 @@ import {
   sendMessage,
   sendTyping,
   uploadToCdn
-} from "./chunk-MZS7GEC7.js";
+} from "./chunk-SMRDCANI.js";
 import {
   ChannelBase,
   isTerminalTaskLifecycleType
-} from "./chunk-E55H6BZ7.js";
+} from "./chunk-IXEZHTDR.js";
 import "./chunk-IW6RQPQB.js";
 import "./chunk-CQ35AJ4Z.js";
 import {
@@ -358,7 +358,6 @@ function validateImagePath(imagePath, workspaceDirs = []) {
 __name(validateImagePath, "validateImagePath");
 async function sendText(params) {
   const { to, text, baseUrl, token, contextToken } = params;
-  const plainText = markdownToPlainText(text);
   await sendMessage(baseUrl, token, {
     to_user_id: to,
     from_user_id: "",
@@ -366,7 +365,7 @@ async function sendText(params) {
     message_type: MessageType.BOT,
     message_state: MessageState.FINISH,
     context_token: contextToken,
-    item_list: [{ type: MessageItemType.TEXT, text_item: { text: plainText } }]
+    item_list: [{ type: MessageItemType.TEXT, text_item: { text } }]
   });
 }
 __name(sendText, "sendText");
@@ -520,40 +519,47 @@ var WeixinChannel = class extends ChannelBase {
     }
   }
   async handleInboundWithMedia(envelope, image, file) {
-    if (image) {
-      try {
-        const imageData = await downloadAndDecrypt(image.encryptQueryParam, image.aesKey);
-        envelope.imageBase64 = imageData.toString("base64");
-        envelope.imageMimeType = detectImageMime(imageData);
-      } catch (err) {
-        process.stderr.write(`[Weixin:${this.name}] Failed to download image: ${err instanceof Error ? err.message : err}
+    await this.prepareThenHandleInbound(envelope, async () => {
+      if (image) {
+        try {
+          const imageData = await downloadAndDecrypt(image.encryptQueryParam, image.aesKey);
+          envelope.imageBase64 = imageData.toString("base64");
+          envelope.imageMimeType = detectImageMime(imageData);
+        } catch (err) {
+          process.stderr.write(`[Weixin:${this.name}] Failed to download image: ${err instanceof Error ? err.message : err}
 `);
+        }
       }
-    }
-    if (file) {
-      try {
-        const fileData = await downloadAndDecrypt(file.encryptQueryParam, file.aesKey);
-        const dir = join2(tmpdir2(), "channel-files", randomUUID2());
-        mkdirSync(dir, { recursive: true });
-        const filePath = join2(dir, basename(file.fileName) || `file_${Date.now()}`);
-        writeFileSync2(filePath, fileData);
-        envelope.attachments = [
-          {
-            type: "file",
-            filePath,
-            mimeType: "application/octet-stream",
-            fileName: file.fileName
-          }
-        ];
-      } catch (err) {
-        process.stderr.write(`[Weixin:${this.name}] Failed to download file: ${err instanceof Error ? err.message : err}
+      if (file) {
+        try {
+          const fileData = await downloadAndDecrypt(file.encryptQueryParam, file.aesKey);
+          const dir = join2(tmpdir2(), "channel-files", randomUUID2());
+          mkdirSync(dir, { recursive: true });
+          const filePath = join2(dir, basename(file.fileName) || `file_${Date.now()}`);
+          writeFileSync2(filePath, fileData);
+          envelope.attachments = [
+            {
+              type: "file",
+              filePath,
+              mimeType: "application/octet-stream",
+              fileName: file.fileName
+            }
+          ];
+        } catch (err) {
+          process.stderr.write(`[Weixin:${this.name}] Failed to download file: ${err instanceof Error ? err.message : err}
 `);
-        envelope.text = `(User sent a file "${file.fileName}" but download failed)`;
+          envelope.text = `(User sent a file "${file.fileName}" but download failed)`;
+        }
       }
-    }
-    await super.handleInbound(envelope);
+    });
   }
   async sendMessage(chatId, text) {
+    await this.sendProjectedMessage(chatId, text);
+  }
+  async sendThreadMessage(chatId, _threadId, text, sourceLabel) {
+    await this.sendProjectedMessage(chatId, text, sourceLabel);
+  }
+  async sendProjectedMessage(chatId, text, sourceLabel) {
     const contextToken = getContextToken(chatId) || "";
     const textWithoutCode = text.replace(/```[\s\S]*?```/g, "").replace(/`[^`]*`/g, "");
     const imageRegex = /\[IMAGE:\s*([^\]]+)\]/gi;
@@ -568,10 +574,12 @@ var WeixinChannel = class extends ChannelBase {
       cleanedText = cleanedText.replace(new RegExp(`\\[IMAGE:\\s*${escapeRegex(path)}\\]`, "gi"), "");
     }
     cleanedText = cleanedText.replace(/\n{3,}/g, "\n\n").trim();
-    if (cleanedText) {
+    const plainText = cleanedText ? markdownToPlainText(cleanedText) : "";
+    const visibleText = plainText ? this.formatAttributedText(plainText, sourceLabel) : parsedImages.length > 0 ? sourceLabel : void 0;
+    if (visibleText) {
       await sendText({
         to: chatId,
-        text: cleanedText,
+        text: visibleText,
         baseUrl: this.baseUrl,
         token: this.token,
         contextToken
@@ -599,7 +607,7 @@ var WeixinChannel = class extends ChannelBase {
           try {
             await sendText({
               to: chatId,
-              text: "\u56FE\u7247\u53D1\u9001\u5931\u8D25\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5",
+              text: this.formatAttributedText("\u56FE\u7247\u53D1\u9001\u5931\u8D25\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5", sourceLabel),
               baseUrl: this.baseUrl,
               token: this.token,
               contextToken

package/chunks/{dist-DJBNNPLN.js → dist-LY66XNUL.js}

@@ -6,7 +6,7 @@ import {
 import "./chunk-7E7UCJHS.js";
 import {
   PollingChannelBase
-} from "./chunk-E55H6BZ7.js";
+} from "./chunk-IXEZHTDR.js";
 import "./chunk-IW6RQPQB.js";
 import {
   external_exports
@@ -13235,7 +13235,7 @@ var GitlabChannel = class extends PollingChannelBase {
   async sendMessage(_chatId, _text) {
     throw new Error(`[Channel:${this.name}] sendMessage requires a threadId; use sendThreadMessage`);
   }
-  async sendThreadMessage(chatId, threadId, text) {
+  async sendThreadMessage(chatId, threadId, text, sourceLabel) {
     if (!threadId) {
       throw new Error(`[Channel:${this.name}] sendThreadMessage requires a threadId (e.g. "issue:42" or "mr:7")`);
     }
@@ -13244,7 +13244,7 @@ var GitlabChannel = class extends PollingChannelBase {
       throw new Error(`[Channel:${this.name}] invalid threadId format: ${threadId}`);
     }
     const targetType = threadId.startsWith("mr:") ? "mr" : "issue";
-    await this.createNote(chatId, targetType, Number(match[1]), text);
+    await this.createNote(chatId, targetType, Number(match[1]), this.formatMarkdownAttributedText(text, sourceLabel));
   }
   onPromptStart(chatId, _sessionId, messageId) {
     if (!messageId)
@@ -13389,6 +13389,13 @@ var GitlabChannel = class extends PollingChannelBase {
     }
     try {
       await this.handleInbound(envelope);
+    } catch (err) {
+      process2.stderr.write(`[Channel:${this.name}] error processing todo ${todo.id}: ${err}
+`);
+      try {
+        await this.createNote(chatId, targetType, target.iid, this.formatMarkdownAttributedText("\u26A0\uFE0F Failed to process this request. Please re-mention the bot to retry.", this.getInboundErrorSourceLabel(envelope)));
+      } catch {
+      }
     } finally {
       this.reactions.delete(messageId);
     }

package/chunks/{dist-7CKN54NL.js → dist-S3BKCTWF.js}

@@ -3,7 +3,7 @@
 import {
   ChannelBase,
   isTerminalTaskLifecycleType
-} from "./chunk-E55H6BZ7.js";
+} from "./chunk-IXEZHTDR.js";
 import "./chunk-IW6RQPQB.js";
 import {
   require_abort_controller,
@@ -9667,6 +9667,7 @@ var TELEGRAM_BOT_COMMANDS = [
   { command: "cancel", description: "Cancel the running request" },
   { command: "status", description: "Show session info" }
 ];
+var TELEGRAM_MESSAGE_LIMIT = 4096;
 var TELEGRAM_START_MESSAGE = [
   "Qwen Code Telegram bot",
   "",
@@ -9711,6 +9712,14 @@ var TelegramChannel = class extends ChannelBase {
   getFileUrl(filePath) {
     return `https://api.telegram.org/file/bot${this.bot.token}/${filePath}`;
   }
+  reportInboundError(envelope, error, reply) {
+    process.stderr.write(`[Telegram:${this.name}] Error handling message: ${error}
+`);
+    const sourceLabel = this.getInboundErrorSourceLabel(envelope);
+    const delivery = sourceLabel ? this.sendThreadMessage(envelope.chatId, envelope.threadId, "Sorry, something went wrong processing your message.", sourceLabel) : reply();
+    delivery.catch(() => {
+    });
+  }
   async connect() {
     if (this.hasConnectedOnce) {
       this.bot = this.createBot();
@@ -9725,10 +9734,7 @@ var TelegramChannel = class extends ChannelBase {
       const text = msg.text;
       const envelope = this.buildEnvelope(msg, text, msg.entities);
       this.handleInbound(envelope).catch((err) => {
-        process.stderr.write(`[Telegram:${this.name}] Error handling message: ${err}
-`);
-        ctx.reply("Sorry, something went wrong processing your message.").catch(() => {
-        });
+        this.reportInboundError(envelope, err, () => ctx.reply("Sorry, something went wrong processing your message."));
       });
     });
     this.bot.on("message:photo", async (ctx) => {
@@ -9737,24 +9743,22 @@ var TelegramChannel = class extends ChannelBase {
       const photo = msg.photo[msg.photo.length - 1];
       if (!photo)
         return;
-      try {
-        const file = await ctx.api.getFile(photo.file_id);
-        const fileUrl = this.getFileUrl(file.file_path);
-        const resp = await fetch(fileUrl);
-        if (!resp.ok)
-          throw new Error(`HTTP ${resp.status}`);
-        const buf = Buffer.from(await resp.arrayBuffer());
-        envelope.imageBase64 = buf.toString("base64");
-        envelope.imageMimeType = "image/jpeg";
-      } catch (err) {
-        process.stderr.write(`[Telegram:${this.name}] Failed to download photo: ${err instanceof Error ? err.message : err}
-`);
-      }
-      this.handleInbound(envelope).catch((err) => {
-        process.stderr.write(`[Telegram:${this.name}] Error handling message: ${err}
+      this.prepareThenHandleInbound(envelope, async () => {
+        try {
+          const file = await ctx.api.getFile(photo.file_id);
+          const fileUrl = this.getFileUrl(file.file_path);
+          const resp = await fetch(fileUrl);
+          if (!resp.ok)
+            throw new Error(`HTTP ${resp.status}`);
+          const buf = Buffer.from(await resp.arrayBuffer());
+          envelope.imageBase64 = buf.toString("base64");
+          envelope.imageMimeType = "image/jpeg";
+        } catch (err) {
+          process.stderr.write(`[Telegram:${this.name}] Failed to download photo: ${err instanceof Error ? err.message : err}
 `);
-        ctx.reply("Sorry, something went wrong processing your message.").catch(() => {
-        });
+        }
+      }).catch((err) => {
+        this.reportInboundError(envelope, err, () => ctx.reply("Sorry, something went wrong processing your message."));
       });
     });
     this.bot.on("message:document", async (ctx) => {
@@ -9762,38 +9766,36 @@ var TelegramChannel = class extends ChannelBase {
       const doc = msg.document;
       const fileName = doc.file_name || `file_${Date.now()}`;
       const envelope = this.buildEnvelope(msg, msg.caption || `(file: ${fileName})`, msg.caption_entities);
-      try {
-        const file = await ctx.api.getFile(doc.file_id);
-        const fileUrl = this.getFileUrl(file.file_path);
-        const resp = await fetch(fileUrl);
-        if (!resp.ok)
-          throw new Error(`HTTP ${resp.status}`);
-        const buf = Buffer.from(await resp.arrayBuffer());
-        const dir = join(tmpdir(), "channel-files", randomUUID());
-        mkdirSync(dir, { recursive: true });
-        const filePath = join(dir, basename(fileName) || `file_${Date.now()}`);
-        writeFileSync(filePath, buf);
-        envelope.text = msg.caption || "";
-        envelope.attachments = [
-          {
-            type: "file",
-            filePath,
-            mimeType: doc.mime_type || "application/octet-stream",
-            fileName
-          }
-        ];
-      } catch (err) {
-        process.stderr.write(`[Telegram:${this.name}] Failed to download document: ${err instanceof Error ? err.message : err}
+      this.prepareThenHandleInbound(envelope, async () => {
+        try {
+          const file = await ctx.api.getFile(doc.file_id);
+          const fileUrl = this.getFileUrl(file.file_path);
+          const resp = await fetch(fileUrl);
+          if (!resp.ok)
+            throw new Error(`HTTP ${resp.status}`);
+          const buf = Buffer.from(await resp.arrayBuffer());
+          const dir = join(tmpdir(), "channel-files", randomUUID());
+          mkdirSync(dir, { recursive: true });
+          const filePath = join(dir, basename(fileName) || `file_${Date.now()}`);
+          writeFileSync(filePath, buf);
+          envelope.text = msg.caption || "";
+          envelope.attachments = [
+            {
+              type: "file",
+              filePath,
+              mimeType: doc.mime_type || "application/octet-stream",
+              fileName
+            }
+          ];
+        } catch (err) {
+          process.stderr.write(`[Telegram:${this.name}] Failed to download document: ${err instanceof Error ? err.message : err}
 `);
-        envelope.text = (msg.caption || "") + `
+          envelope.text = (msg.caption || "") + `
 
 (User sent a file "${fileName}" but download failed)`;
-      }
-      this.handleInbound(envelope).catch((err) => {
-        process.stderr.write(`[Telegram:${this.name}] Error handling message: ${err}
-`);
-        ctx.reply("Sorry, something went wrong processing your message.").catch(() => {
-        });
+        }
+      }).catch((err) => {
+        this.reportInboundError(envelope, err, () => ctx.reply("Sorry, something went wrong processing your message."));
       });
     });
     this.bot.on("message:voice", async (ctx) => {
@@ -9801,38 +9803,36 @@ var TelegramChannel = class extends ChannelBase {
       const voice = msg.voice;
       const fileName = `voice_${Date.now()}.ogg`;
       const envelope = this.buildEnvelope(msg, msg.caption || "(voice message)", msg.caption_entities);
-      try {
-        const file = await ctx.api.getFile(voice.file_id);
-        const fileUrl = this.getFileUrl(file.file_path);
-        const resp = await fetch(fileUrl);
-        if (!resp.ok)
-          throw new Error(`HTTP ${resp.status}`);
-        const buf = Buffer.from(await resp.arrayBuffer());
-        const dir = join(tmpdir(), "channel-files", randomUUID());
-        mkdirSync(dir, { recursive: true });
-        const filePath = join(dir, fileName);
-        writeFileSync(filePath, buf);
-        envelope.text = msg.caption || "";
-        envelope.attachments = [
-          {
-            type: "audio",
-            filePath,
-            mimeType: voice.mime_type || "audio/ogg",
-            fileName
-          }
-        ];
-      } catch (err) {
-        process.stderr.write(`[Telegram:${this.name}] Failed to download voice message: ${err instanceof Error ? err.message : err}
+      this.prepareThenHandleInbound(envelope, async () => {
+        try {
+          const file = await ctx.api.getFile(voice.file_id);
+          const fileUrl = this.getFileUrl(file.file_path);
+          const resp = await fetch(fileUrl);
+          if (!resp.ok)
+            throw new Error(`HTTP ${resp.status}`);
+          const buf = Buffer.from(await resp.arrayBuffer());
+          const dir = join(tmpdir(), "channel-files", randomUUID());
+          mkdirSync(dir, { recursive: true });
+          const filePath = join(dir, fileName);
+          writeFileSync(filePath, buf);
+          envelope.text = msg.caption || "";
+          envelope.attachments = [
+            {
+              type: "audio",
+              filePath,
+              mimeType: voice.mime_type || "audio/ogg",
+              fileName
+            }
+          ];
+        } catch (err) {
+          process.stderr.write(`[Telegram:${this.name}] Failed to download voice message: ${err instanceof Error ? err.message : err}
 `);
-        envelope.text = (msg.caption || "") + `
+          envelope.text = (msg.caption || "") + `
 
 (User sent a voice message but download failed)`;
-      }
-      this.handleInbound(envelope).catch((err) => {
-        process.stderr.write(`[Telegram:${this.name}] Error handling message: ${err}
-`);
-        ctx.reply("Sorry, something went wrong processing your message.").catch(() => {
-        });
+        }
+      }).catch((err) => {
+        this.reportInboundError(envelope, err, () => ctx.reply("Sorry, something went wrong processing your message."));
       });
     });
     this.bot.start({ drop_pending_updates: true }).catch((err) => {
@@ -9913,27 +9913,44 @@ var TelegramChannel = class extends ChannelBase {
     const route = envelope.threadId === void 0 ? {} : { threadId: envelope.threadId };
     await this.inboundRoute.run(route, () => super.handleInbound(envelope));
   }
+  async prepareThenHandleInbound(envelope, prepare) {
+    const route = envelope.threadId === void 0 ? {} : { threadId: envelope.threadId };
+    await this.inboundRoute.run(route, () => super.prepareThenHandleInbound(envelope, prepare));
+  }
   async sendMessage(chatId, text) {
     await this.sendTelegramMessage(chatId, text, this.inboundRoute.getStore()?.threadId);
   }
-  async sendResponseMessage(chatId, text, sessionId) {
+  async sendThreadMessage(chatId, threadId, text, sourceLabel) {
+    await this.sendTelegramMessage(chatId, text, threadId, sourceLabel);
+  }
+  async sendResponseMessage(chatId, text, sessionId, sourceLabel) {
     const inboundRoute = this.inboundRoute.getStore();
     const target = this.router.getTarget(sessionId);
     const threadId = inboundRoute !== void 0 ? inboundRoute.threadId : target?.channelName === this.name && target.chatId === chatId ? target.threadId : void 0;
-    await this.sendTelegramMessage(chatId, text, threadId);
+    await this.sendTelegramMessage(chatId, text, threadId, sourceLabel ?? this.getResponseSourceLabel(sessionId));
   }
-  async pushProactive(target, text) {
-    await this.sendTelegramMessage(target.chatId, text, target.threadId);
+  async pushProactive(target, text, sourceLabel) {
+    await this.sendTelegramMessage(target.chatId, text, target.threadId, sourceLabel);
   }
-  async sendTelegramMessage(chatId, text, threadId) {
+  async sendTelegramMessage(chatId, text, threadId, sourceLabel) {
     const html = telegramFormat(text);
-    const chunks = splitHtmlForTelegram(html);
-    const options = threadId === void 0 ? { parse_mode: "HTML" } : { parse_mode: "HTML", message_thread_id: Number(threadId) };
+    const prefix = sourceLabel && text.trim().length > 0 ? `${escapeTelegramHtml(sourceLabel)} ` : void 0;
+    const chunks = splitAttributedTelegramHtml(html, prefix, sourceLabel);
     for (const chunk of chunks) {
+      const options = chunk.isHtml ? threadId === void 0 ? { parse_mode: "HTML" } : {
+        parse_mode: "HTML",
+        message_thread_id: Number(threadId)
+      } : threadId === void 0 ? void 0 : { message_thread_id: Number(threadId) };
+      if (!chunk.isHtml) {
+        await this.bot.api.sendMessage(chatId, chunk.text, options);
+        continue;
+      }
       try {
-        await this.bot.api.sendMessage(chatId, chunk, options);
+        await this.bot.api.sendMessage(chatId, chunk.text, options);
       } catch {
-        await this.bot.api.sendMessage(chatId, chunk.replace(/<[^>]*>/g, ""), threadId === void 0 ? void 0 : { message_thread_id: Number(threadId) });
+        const withoutTags = chunk.text.replace(/<[^>]*>/g, "");
+        const plainText = prefix && sourceLabel && withoutTags.startsWith(prefix) ? `${sourceLabel} ${withoutTags.slice(prefix.length)}` : withoutTags;
+        await this.bot.api.sendMessage(chatId, plainText, threadId === void 0 ? void 0 : { message_thread_id: Number(threadId) });
       }
     }
   }
@@ -9982,6 +9999,105 @@ var TelegramChannel = class extends ChannelBase {
     };
   }
 };
+function splitAttributedTelegramHtml(html, prefix, sourceLabel) {
+  const chunks = splitHtmlForTelegram(html);
+  const contentLimit = TELEGRAM_MESSAGE_LIMIT - (prefix?.length ?? 0);
+  if (contentLimit <= 0) {
+    throw new Error("Telegram source label exceeds the message limit.");
+  }
+  const attributed = [];
+  for (const chunk of chunks) {
+    const split = splitTelegramHtmlAtLimit(chunk, contentLimit);
+    if (split) {
+      attributed.push(...split.map((part) => ({
+        text: `${prefix ?? ""}${part}`,
+        isHtml: true
+      })));
+      continue;
+    }
+    attributed.push(...splitAttributedTelegramText(chunk.replace(/<[^>]*>/g, ""), sourceLabel).map((text) => ({ text, isHtml: false })));
+  }
+  return attributed;
+}
+__name(splitAttributedTelegramHtml, "splitAttributedTelegramHtml");
+function splitTelegramHtmlAtLimit(html, limit) {
+  const tokens = html.match(/<[^>]+>|&(?:#\d+|#x[\da-f]+|[a-z][\da-z]+);|[\s\S]/giu);
+  if (!tokens)
+    return [];
+  const chunks = [];
+  const openTags = [];
+  let current = "";
+  let hasContent = false;
+  const closingTags = /* @__PURE__ */ __name(() => [...openTags].reverse().map(({ name }) => `</${name}>`).join(""), "closingTags");
+  const reopenedTags = /* @__PURE__ */ __name(() => openTags.map(({ html: html2 }) => html2).join(""), "reopenedTags");
+  const flush = /* @__PURE__ */ __name(() => {
+    if (!hasContent)
+      return false;
+    chunks.push(`${current}${closingTags()}`);
+    current = reopenedTags();
+    hasContent = false;
+    return true;
+  }, "flush");
+  for (const token of tokens) {
+    const closingMatch = token.match(/^<\/([a-z\d]+)/iu);
+    if (closingMatch) {
+      current += token;
+      const index = openTags.findLastIndex(({ name }) => name === closingMatch[1]?.toLowerCase());
+      if (index !== -1)
+        openTags.splice(index, 1);
+      continue;
+    }
+    const openingMatch = token.match(/^<([a-z\d]+)/iu);
+    const isSelfClosing = /^<br\b|\/>$/iu.test(token);
+    if (openingMatch && !isSelfClosing) {
+      const tag = { name: openingMatch[1].toLowerCase(), html: token };
+      const required = `${current}${token}</${tag.name}>${closingTags()}`;
+      if (required.length > limit && !flush())
+        return void 0;
+      if (`${current}${token}</${tag.name}>${closingTags()}`.length > limit) {
+        return void 0;
+      }
+      current += token;
+      openTags.push(tag);
+      continue;
+    }
+    if (`${current}${token}${closingTags()}`.length > limit && !flush()) {
+      return void 0;
+    }
+    if (`${current}${token}${closingTags()}`.length > limit)
+      return void 0;
+    current += token;
+    hasContent = true;
+  }
+  if (hasContent)
+    chunks.push(`${current}${closingTags()}`);
+  return chunks;
+}
+__name(splitTelegramHtmlAtLimit, "splitTelegramHtmlAtLimit");
+function splitAttributedTelegramText(text, sourceLabel) {
+  if (text.length === 0)
+    return [];
+  const prefix = sourceLabel ? `${sourceLabel} ` : "";
+  const contentLimit = TELEGRAM_MESSAGE_LIMIT - prefix.length;
+  if (contentLimit <= 0) {
+    throw new Error("Telegram source label exceeds the message limit.");
+  }
+  const chunks = [];
+  for (let offset = 0; offset < text.length; ) {
+    let end = Math.min(offset + contentLimit, text.length);
+    if (end < text.length && /[\uD800-\uDBFF]/u.test(text[end - 1] ?? "") && /[\uDC00-\uDFFF]/u.test(text[end] ?? "")) {
+      end--;
+    }
+    chunks.push(`${prefix}${text.slice(offset, end)}`);
+    offset = end;
+  }
+  return chunks;
+}
+__name(splitAttributedTelegramText, "splitAttributedTelegramText");
+function escapeTelegramHtml(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+__name(escapeTelegramHtml, "escapeTelegramHtml");
 
 // packages/channels/telegram/dist/index.js
 var plugin = {

package/chunks/{dist-UQUFZDIY.js → dist-SDKHGH5O.js}

@@ -10,7 +10,7 @@ import "./chunk-7E7UCJHS.js";
 import {
   ChannelBase,
   sanitizeLogText
-} from "./chunk-E55H6BZ7.js";
+} from "./chunk-IXEZHTDR.js";
 import "./chunk-IW6RQPQB.js";
 import "./chunk-CQ35AJ4Z.js";
 import "./chunk-DMTGGOSA.js";
@@ -1756,12 +1756,23 @@ var WeComChannel = class extends ChannelBase {
     return true;
   }
   async sendMessage(chatId, text) {
+    await this.sendAttributedMessage(chatId, text);
+  }
+  async sendThreadMessage(chatId, _threadId, text, sourceLabel) {
+    await this.sendAttributedMessage(chatId, text, sourceLabel);
+  }
+  async sendAttributedMessage(chatId, text, sourceLabel) {
     const client = this.client;
     if (!client) {
       throw new Error(`[WeCom:${this.name}] No active SDK client, cannot send.`);
     }
     const { cleanedText, media } = parseOutboundMediaMarkers(text);
-    const chunks = splitMarkdownChunks(cleanedText);
+    const prefix = sourceLabel && (cleanedText.trim().length > 0 || media.length > 0) ? `${escapeWeComMarkdown(sourceLabel)}
+` : void 0;
+    const chunks = splitMarkdownChunks(cleanedText, prefix);
+    if (chunks.length === 0 && media.length > 0 && prefix) {
+      chunks.push(prefix.trimEnd());
+    }
     if (chunks.length === 0 && media.length === 0) {
       process.stderr.write(`[WeCom:${this.name}] sendMessage produced empty payload for chatId=${sanitizeLogText(chatId, 100)}.
 `);
@@ -1867,22 +1878,24 @@ var WeComChannel = class extends ChannelBase {
 `);
         return;
       }
-      attachments = await this.downloadAttachments(body, attachments, messageId, attachmentRouteKey, connectionGeneration);
-      if (this.disconnectGeneration !== connectionGeneration) {
-        process.stderr.write(`[WeCom:${this.name}] dropping message ${logMessageId}: connection changed during attachment download.
+      await this.processPreflightedInbound(envelope, async () => {
+        attachments = await this.downloadAttachments(body, attachments, messageId, attachmentRouteKey, connectionGeneration);
+        if (this.disconnectGeneration !== connectionGeneration) {
+          process.stderr.write(`[WeCom:${this.name}] dropping message ${logMessageId}: connection changed during attachment download.
 `);
-        return;
-      }
-      if (attachments.length) {
-        envelope.attachments = attachments;
-      }
-      if (!envelope.text && attachments.length) {
-        envelope.text = attachments.some((a) => a.type === "image") ? "(image)" : `(file: ${attachments[0]?.fileName ?? "file"})`;
-      }
-      if (rawMessageId)
-        this.seenMessages.set(rawMessageId, Date.now());
-      processStarted = true;
-      await this.processInbound(envelope);
+          return;
+        }
+        if (attachments.length) {
+          envelope.attachments = attachments;
+        }
+        if (!envelope.text && attachments.length) {
+          envelope.text = attachments.some((a) => a.type === "image") ? "(image)" : `(file: ${attachments[0]?.fileName ?? "file"})`;
+        }
+        if (rawMessageId)
+          this.seenMessages.set(rawMessageId, Date.now());
+        processStarted = true;
+        await this.processInbound(envelope);
+      });
     } catch (err) {
       if (rawMessageId && !processStarted) {
         this.seenMessages.delete(rawMessageId);
@@ -2649,14 +2662,18 @@ function isWeComMediaType(value) {
   return value === "image" || value === "file" || value === "voice" || value === "video";
 }
 __name(isWeComMediaType, "isWeComMediaType");
-function splitMarkdownChunks(text) {
+function splitMarkdownChunks(text, prefix) {
   if (!text)
     return [];
+  const contentLimit = MARKDOWN_CHUNK_BYTES - Buffer2.byteLength(prefix ?? "");
+  if (contentLimit <= 0) {
+    throw new Error("WeCom source label exceeds the markdown message limit.");
+  }
   const chunks = [];
   let current = "";
   let codeFence;
   const fits = /* @__PURE__ */ __name((value, nextCodeFence = codeFence) => Buffer2.byteLength(nextCodeFence ? `${value}
-${nextCodeFence}` : value, "utf8") <= MARKDOWN_CHUNK_BYTES, "fits");
+${nextCodeFence}` : value, "utf8") <= contentLimit, "fits");
   const flush = /* @__PURE__ */ __name((closeCode = true) => {
     if (!current)
       return;
@@ -2705,9 +2722,13 @@ ${token}` : token;
     }
   }
   flush();
-  return chunks;
+  return prefix ? chunks.map((chunk) => `${prefix}${chunk}`) : chunks;
 }
 __name(splitMarkdownChunks, "splitMarkdownChunks");
+function escapeWeComMarkdown(value) {
+  return value.replace(/([\\`*_{}[\]()#+\-.!|>])/gu, "\\$1");
+}
+__name(escapeWeComMarkdown, "escapeWeComMarkdown");
 function toggleCodeFenceState(line, codeFence) {
   let nextCodeFence = codeFence;
   for (const match of line.matchAll(/```|~~~/g)) {