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

package/chunks/{dist-TJUDJTCB.js → dist-5423MG3D.js}

@@ -14,7 +14,7 @@ import {
   sanitizePromptText,
   sanitizeSenderName,
   truncateUtf16Units
-} from "./chunk-E55H6BZ7.js";
+} from "./chunk-IXEZHTDR.js";
 import "./chunk-IW6RQPQB.js";
 import "./chunk-CQ35AJ4Z.js";
 import "./chunk-DMTGGOSA.js";
@@ -5792,9 +5792,21 @@ var DWClient = class extends EventEmitter2 {
 
 // packages/channels/dingtalk/dist/markdown.js
 init_esbuild_shims();
-var CHUNK_LIMIT = 3800;
-function splitChunks(text) {
-  if (!text || text.length <= CHUNK_LIMIT) {
+var DINGTALK_CHUNK_LIMIT = 3800;
+function escapeDingTalkMarkdown(value) {
+  return value.replace(/([\\`*_[\]{}()#+.!|>~:-])/gu, "\\$1");
+}
+__name(escapeDingTalkMarkdown, "escapeDingTalkMarkdown");
+function safeUtf16SliceEnd(value, end) {
+  if (end <= 0 || end >= value.length)
+    return end;
+  const previous = value.charCodeAt(end - 1);
+  const next = value.charCodeAt(end);
+  return previous >= 55296 && previous <= 56319 && next >= 56320 && next <= 57343 ? end - 1 : end;
+}
+__name(safeUtf16SliceEnd, "safeUtf16SliceEnd");
+function splitChunks(text, chunkLimit = DINGTALK_CHUNK_LIMIT) {
+  if (!text || text.length <= chunkLimit) {
     return [text];
   }
   const chunks = [];
@@ -5814,11 +5826,15 @@ function splitChunks(text) {
     let lineOpenedFenceInBuffer = false;
     while (remaining.length > 0 || prefixPending) {
       const prefix = prefixPending ? "\n" : "";
-      const fitsAsFinalPiece = remaining.length <= CHUNK_LIMIT - buf.length - prefix.length;
+      const fitsAsFinalPiece = remaining.length <= chunkLimit - buf.length - prefix.length;
       const closeFenceOverhead = inCode && !(closesCodeFence && fitsAsFinalPiece) || !inCode && leavesCodeFenceOpen ? "\n```".length : 0;
-      const available = CHUNK_LIMIT - closeFenceOverhead - buf.length - prefix.length;
+      const available = chunkLimit - closeFenceOverhead - buf.length - prefix.length;
       if (available <= 0) {
-        flush(inCode || lineOpenedFenceInBuffer);
+        const keepCodeOpen = inCode || lineOpenedFenceInBuffer;
+        if (buf === (keepCodeOpen ? "```" : "")) {
+          throw new RangeError("chunk limit cannot contain one Unicode character");
+        }
+        flush(keepCodeOpen);
         continue;
       }
       let pieceLength = Math.min(available, remaining.length);
@@ -5830,8 +5846,13 @@ function splitChunks(text) {
           }
         }
       }
+      pieceLength = safeUtf16SliceEnd(remaining, pieceLength);
       if (pieceLength === 0 && remaining.length > 0) {
-        flush(inCode || lineOpenedFenceInBuffer);
+        const keepCodeOpen = inCode || lineOpenedFenceInBuffer;
+        if (!buf || keepCodeOpen && buf === "```") {
+          throw new RangeError("chunk limit cannot contain one Unicode character");
+        }
+        flush(keepCodeOpen);
         continue;
       }
       const piece = remaining.slice(0, pieceLength);
@@ -5868,8 +5889,8 @@ function extractTitle(text) {
   return cleaned || "Reply";
 }
 __name(extractTitle, "extractTitle");
-function normalizeDingTalkMarkdown(text) {
-  return splitChunks(text);
+function normalizeDingTalkMarkdown(text, chunkLimit = DINGTALK_CHUNK_LIMIT) {
+  return splitChunks(text, chunkLimit);
 }
 __name(normalizeDingTalkMarkdown, "normalizeDingTalkMarkdown");
 
@@ -6154,6 +6175,109 @@ async function uploadDingTalkImage(image, accessToken) {
 }
 __name(uploadDingTalkImage, "uploadDingTalkImage");
 
+// packages/channels/dingtalk/dist/outbound-file.js
+init_esbuild_shims();
+var FILE_OPENING = "[FILE:";
+var MAX_FILE_PATH_CHARS = 4096;
+var MAX_FILES_PER_RESPONSE = 5;
+var FILE_UNAVAILABLE_NOTICE = "[File delivery unavailable]";
+var OutboundFileProjector = class {
+  static {
+    __name(this, "OutboundFileProjector");
+  }
+  candidate = "";
+  reserved = "";
+  reservedAtLineStart = false;
+  reservedTooLong = false;
+  atLineStart = true;
+  paths = [];
+  invalidMarkers = 0;
+  excessMarkers = 0;
+  markerCount = 0;
+  append(chunk) {
+    let safe = "";
+    for (const char of chunk) {
+      if (this.reserved) {
+        if (char === "\n") {
+          this.finishReservedLine();
+          safe += "\n";
+          this.atLineStart = true;
+        } else if (this.reserved.length <= MAX_FILE_PATH_CHARS + 9) {
+          this.reserved += char;
+        } else {
+          this.reservedTooLong = true;
+        }
+        continue;
+      }
+      if (char === "\n") {
+        safe += `${this.candidate}
+`;
+        this.candidate = "";
+        this.atLineStart = true;
+        continue;
+      }
+      this.candidate += char;
+      while (this.candidate && !FILE_OPENING.startsWith(this.candidate)) {
+        safe += this.candidate[0];
+        this.candidate = this.candidate.slice(1);
+        this.atLineStart = false;
+      }
+      if (this.candidate === FILE_OPENING) {
+        this.reserved = this.candidate;
+        this.reservedAtLineStart = this.atLineStart;
+        this.candidate = "";
+        this.markerCount++;
+      }
+    }
+    return safe;
+  }
+  complete() {
+    if (!this.reserved) {
+      const safe = this.candidate;
+      this.candidate = "";
+      return safe;
+    }
+    this.finishReservedLine();
+    return "";
+  }
+  result(text) {
+    return {
+      text,
+      paths: [...this.paths],
+      invalidMarkers: this.invalidMarkers,
+      excessMarkers: this.excessMarkers,
+      markerCount: this.markerCount
+    };
+  }
+  finishReservedLine() {
+    const match = /^\[FILE: ([^\]\r\n]+)\]\r?$/u.exec(this.reserved);
+    const path = match?.[1];
+    if (!this.reservedTooLong && this.reservedAtLineStart && path && path.length <= MAX_FILE_PATH_CHARS && path === path.trim()) {
+      if (this.paths.length < MAX_FILES_PER_RESPONSE) {
+        this.paths.push(path);
+      } else {
+        this.excessMarkers++;
+      }
+    } else {
+      this.invalidMarkers++;
+    }
+    this.reserved = "";
+    this.reservedAtLineStart = false;
+    this.reservedTooLong = false;
+  }
+};
+function projectFileText(text) {
+  const projector = new OutboundFileProjector();
+  const safe = projector.append(text) + projector.complete();
+  return projector.result(safe);
+}
+__name(projectFileText, "projectFileText");
+function withFileUnavailableNotice(text) {
+  const safe = text.trimEnd();
+  return `${safe}${safe ? "\n" : ""}${FILE_UNAVAILABLE_NOTICE}`;
+}
+__name(withFileUnavailableNotice, "withFileUnavailableNotice");
+
 // packages/channels/dingtalk/dist/DingtalkConnectionManager.js
 init_esbuild_shims();
 var SOCKET_OPEN = 1;
@@ -7105,7 +7229,7 @@ var QuestionCardController = class {
       }
       await this.finalize(record, "cancelled");
       try {
-        await this.options.sendFallback(context.target.chatId, this.fallbackText(context));
+        await this.options.sendFallback(context.target.chatId, this.fallbackText(context), ...context.sourceLabel ? [context.sourceLabel] : []);
       } catch (fallbackError) {
         this.options.onError?.("question fallback delivery", fallbackError);
       }
@@ -7247,22 +7371,22 @@ var QuestionCardController = class {
     const cardParamMap = {
       submitted: {
         card_status: "submitted",
-        question_desc: "Submitted.",
+        question_desc: this.withSourceLabel(record.context, "Submitted."),
         form_btn_text: "Submitted"
       },
       expired: {
         card_status: "expired",
-        question_desc: "This question expired. Please retry.",
+        question_desc: this.withSourceLabel(record.context, "This question expired. Please retry."),
         form_btn_text: "Expired"
       },
       resolved_outside_presenter: {
         card_status: "expired",
-        question_desc: "Resolved outside this card.",
+        question_desc: this.withSourceLabel(record.context, "Resolved outside this card."),
         form_btn_text: "Expired"
       },
       cancelled: {
         card_status: "cancelled",
-        question_desc: "Cancelled.",
+        question_desc: this.withSourceLabel(record.context, "Cancelled."),
         form_btn_text: "Cancelled"
       }
     };
@@ -7271,7 +7395,9 @@ var QuestionCardController = class {
         outTrackId: record.outTrackId,
         cardParamMap: {
           ...cardParamMap[record.terminalState],
-          ...record.terminalDescription ? { question_desc: record.terminalDescription } : {}
+          ...record.terminalDescription ? {
+            question_desc: this.withSourceLabel(record.context, record.terminalDescription)
+          } : {}
         }
       });
     } catch (error) {
@@ -7331,7 +7457,7 @@ var QuestionCardController = class {
     return {
       question_id: context.requestId,
       question_title: first.header,
-      question_desc: first.question,
+      question_desc: this.withSourceLabel(context, first.question),
       card_status: "pending",
       form_btn_text: "Submit",
       selected_text: "",
@@ -7367,19 +7493,27 @@ var QuestionCardController = class {
     return `The interactive question could not be delivered, so this request was cancelled. Please retry.
 ${questions}`;
   }
+  withSourceLabel(context, text) {
+    if (!context.sourceLabel)
+      return text;
+    const label = escapeDingTalkMarkdown(context.sourceLabel);
+    return `${label}
+
+${text}`;
+  }
 };
 
 // packages/channels/dingtalk/dist/interaction-presenter.js
 init_esbuild_shims();
 import { randomUUID as randomUUID4 } from "node:crypto";
-function escapeMarkdownText(text) {
+function escapeSenderMarkdownText(text) {
   return text.replace(/([\\`*_[\]{}()#+.!|>~-])/gu, "\\$1");
 }
-__name(escapeMarkdownText, "escapeMarkdownText");
+__name(escapeSenderMarkdownText, "escapeSenderMarkdownText");
 function formatSenderPrefixes(sender) {
   const senderName = sanitizeSenderName(sender.senderName);
   return {
-    senderPrefix: `@${escapeMarkdownText(senderName)}`,
+    senderPrefix: `@${escapeSenderMarkdownText(senderName)}`,
     senderRawPrefix: `@${senderName}`
   };
 }
@@ -7395,7 +7529,7 @@ var DingtalkInteractionPresenter = class {
   constructor(options) {
     this.options = options;
   }
-  registerRun(runId, ownerId, target, sessionId = "", sender) {
+  registerRun(runId, ownerId, target, sessionId = "", sender, sourceLabel) {
     this.runs.set(runId, {
       runId,
       ownerId,
@@ -7411,10 +7545,12 @@ var DingtalkInteractionPresenter = class {
           chatId: target.chatId,
           senderId: ownerId,
           isGroup: target.isGroup
-        }
+        },
+        sourceLabel
       },
       projectionChain: Promise.resolve(),
       ...target.isGroup && sender ? formatSenderPrefixes(sender) : {},
+      ...sourceLabel ? { sourceLabel } : {},
       terminal: false
     });
   }
@@ -7426,7 +7562,7 @@ var DingtalkInteractionPresenter = class {
     void this.enqueue(run, () => {
       const statusCards = this.options.statusCards;
       const target = this.cardTarget(statusContext.target);
-      statusCards?.ensure(statusContext, target);
+      statusCards?.replace(statusContext, target, this.withSourcePrefix(run, ""));
     });
   }
   appendOutput(segment, chunk) {
@@ -7447,7 +7583,7 @@ var DingtalkInteractionPresenter = class {
     run.activeSegmentId = segment.segmentId;
     const statusContext = this.ensureStatusContext(run, segment);
     void this.enqueue(run, () => {
-      this.options.statusCards?.replace(statusContext, this.cardTarget(statusContext.target), presentation.content);
+      this.options.statusCards?.replace(statusContext, this.cardTarget(statusContext.target), this.withSourcePrefix(run, presentation.content));
     });
   }
   closeOutput(segmentId, text, reason, segment) {
@@ -7491,7 +7627,7 @@ var DingtalkInteractionPresenter = class {
         const fallbackText2 = stripPartialImageMarker(text || presentation.content);
         if (!fallbackText2 || !this.options.sendFallback)
           return false;
-        await this.options.sendFallback(presentation.context.target.chatId, fallbackText2, presentation.context.sessionId);
+        await this.sendFallback(run, presentation.context.target.chatId, fallbackText2, presentation.context.sessionId);
         return true;
       }
       if (reason === "input_requested") {
@@ -7502,7 +7638,7 @@ var DingtalkInteractionPresenter = class {
         const fallbackText2 = stripPartialImageMarker(text || presentation.content);
         if (!fallbackText2 || !this.options.sendFallback)
           return false;
-        await this.options.sendFallback(presentation.context.target.chatId, fallbackText2, presentation.context.sessionId);
+        await this.sendFallback(run, presentation.context.target.chatId, fallbackText2, presentation.context.sessionId);
         return true;
       }
       statusCards?.ensure(statusContext, this.cardTarget(statusContext.target));
@@ -7512,7 +7648,7 @@ var DingtalkInteractionPresenter = class {
       const fallbackText = stripPartialImageMarker(text || presentation.content);
       if (!fallbackText || !this.options.sendFallback)
         return false;
-      await this.options.sendFallback(presentation.context.target.chatId, fallbackText, presentation.context.sessionId);
+      await this.sendFallback(run, presentation.context.target.chatId, fallbackText, presentation.context.sessionId);
       return true;
     });
   }
@@ -7554,7 +7690,7 @@ var DingtalkInteractionPresenter = class {
       } else {
         const statusContext = run.statusContext;
         if (statusContext) {
-          await this.options.statusCards?.complete(statusContext.segmentId, "", (retained) => retained ? this.withSenderPrefix(run, retained) : retained);
+          await this.options.statusCards?.complete(statusContext.segmentId, "", (retained) => retained ? this.withSenderPrefix(run, this.withoutRenderedSourcePrefix(run, retained)) : retained);
         }
       }
     });
@@ -7597,7 +7733,7 @@ var DingtalkInteractionPresenter = class {
     if (!delivered || !this.options.sendFallback)
       return;
     run.cardDelivered = void 0;
-    await this.options.sendFallback(delivered.chatId, delivered.text, delivered.sessionId);
+    await this.sendFallback(run, delivered.chatId, delivered.text, delivered.sessionId);
   }
   enqueue(run, operation) {
     const result = run.projectionChain.then(operation);
@@ -7614,14 +7750,38 @@ var DingtalkInteractionPresenter = class {
     return `${TRUNCATION_MARKER}${content.slice(content.length - (limit - TRUNCATION_MARKER.length))}`;
   }
   withSenderPrefix(run, content) {
-    if (!run.senderPrefix)
+    const prefixes = [
+      run.senderPrefix,
+      run.sourceLabel ? escapeDingTalkMarkdown(run.sourceLabel) : void 0
+    ].filter((value) => Boolean(value));
+    if (prefixes.length === 0)
       return this.boundContent(content);
     const body = this.withoutExistingSenderPrefix(run, content);
+    const prefix = prefixes.join("\n\n");
     if (!body)
-      return run.senderPrefix;
+      return prefix;
     const separator = "\n\n";
-    const bodyLimit = Math.max(0, CONTENT_LIMIT - run.senderPrefix.length - separator.length);
-    return `${run.senderPrefix}${separator}${this.boundContent(body, bodyLimit)}`;
+    const bodyLimit = Math.max(0, CONTENT_LIMIT - prefix.length - separator.length);
+    return `${prefix}${separator}${this.boundContent(body, bodyLimit)}`;
+  }
+  withSourcePrefix(run, content) {
+    if (!run.sourceLabel)
+      return this.boundContent(content);
+    const sourceLabel = escapeDingTalkMarkdown(run.sourceLabel);
+    if (!content)
+      return sourceLabel;
+    return `${sourceLabel}
+
+${this.boundContent(content, Math.max(0, CONTENT_LIMIT - sourceLabel.length - 2))}`;
+  }
+  async sendFallback(run, chatId, text, sessionId) {
+    if (!this.options.sendFallback)
+      return;
+    if (run.sourceLabel) {
+      await this.options.sendFallback(chatId, text, sessionId, run.sourceLabel);
+      return;
+    }
+    await this.options.sendFallback(chatId, text, sessionId);
   }
   withoutExistingSenderPrefix(run, content) {
     const prefixes = /* @__PURE__ */ new Set([run.senderPrefix, run.senderRawPrefix]);
@@ -7647,6 +7807,17 @@ var DingtalkInteractionPresenter = class {
     }
     return body;
   }
+  withoutRenderedSourcePrefix(run, content) {
+    if (!run.sourceLabel)
+      return content;
+    const rendered = escapeDingTalkMarkdown(run.sourceLabel);
+    if (content === rendered)
+      return "";
+    const prefix = `${rendered}
+
+`;
+    return content.startsWith(prefix) ? content.slice(prefix.length) : content;
+  }
   ensureStatusContext(run, segment) {
     if (run.statusContext)
       return run.statusContext;
@@ -7879,6 +8050,7 @@ var DIRECT_MSG_API = "https://api.dingtalk.com/v1.0/robot/oToMessages/batchSend"
 var PROACTIVE_MSG_KEY = "sampleMarkdown";
 var TOKEN_API = "https://oapi.dingtalk.com/gettoken";
 var PROACTIVE_FETCH_TIMEOUT_MS = 15e3;
+var REPLY_FETCH_TIMEOUT_MS = 15e3;
 var GENERATED_MEDIA_EXT = {
   "image/jpeg": "jpg",
   "image/png": "png",
@@ -7954,6 +8126,18 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
   inboundCardOwners = /* @__PURE__ */ new Map();
   cardRunBySession = /* @__PURE__ */ new Map();
   cardRuns = /* @__PURE__ */ new Map();
+  // Keyed by runId, not segmentId: a mid-turn segment reset (response
+  // boundary, input requested) mints a fresh segment UUID but the projection
+  // state must survive it, or a marker split across the reset leaks.
+  fileProjectors = /* @__PURE__ */ new Map();
+  blockFileProjectors = /* @__PURE__ */ new Map();
+  // Sessions armed for block projection by onPromptStart and disarmed when
+  // the turn settles (or the session dies). A block send that finds NO
+  // projector state is only legitimate as a turn's FIRST block, which always
+  // lands while armed: late sends from an evicted (/clear) or dead session
+  // must be dropped, because recreating state would post the tail of a
+  // force-split [FILE: ...] marker verbatim.
+  blockProjectionArmed = /* @__PURE__ */ new Set();
   constructor(name, config, bridge, options) {
     super(name, config, bridge, options);
     this.atSender = config["atSender"] === true;
@@ -7997,7 +8181,7 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
         this.questionCardController = new QuestionCardController({
           client: this.interactiveCardClient,
           timeoutMs: this.interactiveCardConfig.questionCard.timeoutMs,
-          sendFallback: /* @__PURE__ */ __name((chatId, text) => this.sendMessage(chatId, text), "sendFallback"),
+          sendFallback: /* @__PURE__ */ __name((chatId, text, sourceLabel) => this.sendReply(chatId, text, void 0, sourceLabel), "sendFallback"),
           reserveRunProjection: /* @__PURE__ */ __name((runId) => this.interactionPresenter?.reserveProjection(runId), "reserveRunProjection"),
           onError: /* @__PURE__ */ __name((operation, error) => {
             process.stderr.write(`[DingTalk:${this.name}] ${operation} failed: ${sanitizeLogText(String(error), 300)}
@@ -8010,7 +8194,7 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
           statusCards: this.statusCardController,
           questionCards: this.questionCardController,
           ...config.blockStreaming !== "on" ? {
-            sendFallback: /* @__PURE__ */ __name((chatId, text, sessionId) => this.sendFallbackReply(chatId, text, sessionId), "sendFallback")
+            sendFallback: /* @__PURE__ */ __name((chatId, text, sessionId, sourceLabel) => this.sendFallbackReply(chatId, text, sessionId, sourceLabel), "sendFallback")
           } : {}
         });
       }
@@ -8199,10 +8383,21 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
   static isUnroutableGroupMessage(isGroup, conversationId) {
     return isGroup && !conversationId;
   }
-  async prepareOutgoingText(text) {
-    const markers = findImageMarkers(text);
+  projectOutgoingFileText(text, streamed) {
+    const projection = projectFileText(text);
+    const streamedMarkers = streamed ? streamed.result("").markerCount : 0;
+    if (projection.markerCount === 0 && streamedMarkers === 0) {
+      return projection.text;
+    }
+    process.stderr.write(`[DingTalk:${this.name}] file markers redacted (final=${projection.markerCount}, streamed=${streamedMarkers})
+`);
+    return withFileUnavailableNotice(projection.text);
+  }
+  async prepareOutgoingText(text, streamed) {
+    const fileSafeText = this.projectOutgoingFileText(text, streamed);
+    const markers = findImageMarkers(fileSafeText);
     if (markers.length === 0)
-      return text;
+      return fileSafeText;
     const replacements = [];
     for (const marker of markers) {
       const fileName = basename2(marker.path).replace(/[\r\n[\]]+/g, "_").slice(0, 100) || "image";
@@ -8234,9 +8429,9 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
         replacements.push(`[Image delivery failed: ${fileName}]`);
       }
     }
-    return replaceImageMarkers(text, markers, replacements);
+    return replaceImageMarkers(fileSafeText, markers, replacements);
   }
-  async sendReply(chatId, text, atUserId) {
+  async sendReply(chatId, text, atUserId, sourceLabel) {
     const webhook = this.webhooks.get(chatId);
     if (!webhook) {
       process.stderr.write(`[DingTalk:${this.name}] No webhook for chatId ${chatId}, cannot send.
@@ -8247,7 +8442,14 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
     const mentionPrefix = atUserId ? `@${atUserId}
 
 ` : "";
-    const chunks = normalizeDingTalkMarkdown(mentionPrefix + outgoingText);
+    const sourcePrefix = sourceLabel && outgoingText.trim().length > 0 ? `${escapeDingTalkMarkdown(sourceLabel)}
+
+` : "";
+    const contentLimit = DINGTALK_CHUNK_LIMIT - mentionPrefix.length - sourcePrefix.length;
+    if (contentLimit <= 0) {
+      throw new Error("DingTalk source label exceeds the message limit.");
+    }
+    const chunks = normalizeDingTalkMarkdown(outgoingText, contentLimit).map((chunk, index) => `${index === 0 ? mentionPrefix : ""}${sourcePrefix}${chunk}`);
     const title = extractTitle(outgoingText);
     for (let i = 0; i < chunks.length; i++) {
       const chunk = chunks[i];
@@ -8260,11 +8462,19 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
         },
         ...isMention ? { at: { atUserIds: [atUserId] } } : {}
       };
-      const resp = await fetch(webhook, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify(body)
-      });
+      let resp;
+      try {
+        resp = await fetch(webhook, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(body),
+          signal: AbortSignal.timeout(REPLY_FETCH_TIMEOUT_MS)
+        });
+      } catch (err) {
+        process.stderr.write(`[DingTalk:${this.name}] sendMessage failed: ${sanitizeLogText(err instanceof Error ? err.message : String(err), 300)}
+`);
+        throw err;
+      }
       if (isMention && process.env["QWEN_CHANNEL_DEBUG_MENTIONS"] === "1") {
         const payload = await resp.clone().json().catch(() => void 0);
         const response = payload && typeof payload === "object" ? payload : {};
@@ -8283,6 +8493,9 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
   async sendMessage(chatId, text) {
     await this.sendReply(chatId, text);
   }
+  async sendThreadMessage(chatId, _threadId, text, sourceLabel) {
+    await this.sendReply(chatId, text, void 0, sourceLabel);
+  }
   supportsProactiveSend() {
     return true;
   }
@@ -8301,11 +8514,18 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
    * Single-shot cold send: a failed chunk aborts the remainder (already-sent
    * chunks are not recalled) and the error surfaces in the loop's lastError.
    */
-  async pushProactive(target, text) {
+  async pushProactive(target, text, sourceLabel) {
     if (!text.trim())
       return;
     const outgoingText = await this.prepareOutgoingText(text);
-    const chunks = normalizeDingTalkMarkdown(outgoingText);
+    const sourcePrefix = sourceLabel ? `${escapeDingTalkMarkdown(sourceLabel)}
+
+` : "";
+    const contentLimit = DINGTALK_CHUNK_LIMIT - sourcePrefix.length;
+    if (contentLimit <= 0) {
+      throw new Error("DingTalk source label exceeds the message limit.");
+    }
+    const chunks = normalizeDingTalkMarkdown(outgoingText, contentLimit).map((chunk) => `${sourcePrefix}${chunk}`);
     const title = extractTitle(outgoingText);
     for (let i = 0; i < chunks.length; i++) {
       await this.sendProactiveChunk(target, i === 0 ? title : `${title} (cont.)`, chunks[i], `chunk ${i + 1}/${chunks.length}`);
@@ -8555,6 +8775,12 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
   }
   /** Recall reactions left behind when a session dies without terminal lifecycle events. */
   onSessionDied(sessionId) {
+    this.blockProjectionArmed.delete(sessionId);
+    this.blockFileProjectors.delete(sessionId);
+    for (const [runId, state] of this.fileProjectors) {
+      if (state.sessionId === sessionId)
+        this.fileProjectors.delete(runId);
+    }
     const bufferedTargets = this.bufferedMentionTargetsBySession.get(sessionId);
     if (bufferedTargets) {
       this.bufferedMentionTargetsBySession.delete(sessionId);
@@ -8592,7 +8818,8 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
       if (event.runId && event.owner && inboundOwner?.ownerId === event.owner.id) {
         this.cardRuns.set(event.runId, inboundOwner);
         this.cardRunBySession.set(event.sessionId, event.runId);
-        this.interactionPresenter?.registerRun(event.runId, event.owner.id, inboundOwner.target, event.sessionId, inboundOwner.sender);
+        const sourceLabel = this.getResponseSourceLabel(event.sessionId);
+        this.interactionPresenter?.registerRun(event.runId, event.owner.id, inboundOwner.target, event.sessionId, inboundOwner.sender, ...sourceLabel ? [sourceLabel] : []);
         this.interactionPresenter?.startStatusCard(event.runId);
       }
       return;
@@ -8602,6 +8829,7 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
         this.mentionTargets.delete(event.messageId);
       this.stopReaction(event.chatId, event.messageId, event.sessionId);
       if (event.runId) {
+        this.deleteFileProjectorsForRun(event.runId);
         if (event.type === "failed") {
           this.interactionPresenter?.terminalizeRun(event.runId, "failed", event.error);
         } else if (event.type === "cancelled") {
@@ -8644,6 +8872,7 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
     }
   }
   onPromptStart(chatId, sessionId, messageId) {
+    this.blockProjectionArmed.add(sessionId);
     if (messageId) {
       this.bufferedMentionTargets.delete(messageId);
       this.untrackBufferedMentionTarget(sessionId, messageId);
@@ -8658,32 +8887,34 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
   async handleInbound(envelope) {
     if (!await this.preflightInbound(envelope))
       return;
-    const messageId = envelope.messageId;
-    if (messageId && envelope.senderId) {
-      this.inboundCardOwners.delete(messageId);
-      this.inboundCardOwners.set(messageId, {
-        ownerId: envelope.senderId,
-        target: {
-          chatId: envelope.chatId,
-          isGroup: envelope.isGroup
-        },
-        ...this.atSender && envelope.isGroup ? {
-          sender: {
-            senderName: envelope.senderName
-          }
-        } : {}
-      });
-      if (this.inboundCardOwners.size > 1e3) {
-        const oldest = this.inboundCardOwners.keys().next().value;
-        if (oldest !== void 0)
-          this.inboundCardOwners.delete(oldest);
+    await this.processPreflightedInbound(envelope, async () => {
+      const messageId = envelope.messageId;
+      if (messageId && envelope.senderId) {
+        this.inboundCardOwners.delete(messageId);
+        this.inboundCardOwners.set(messageId, {
+          ownerId: envelope.senderId,
+          target: {
+            chatId: envelope.chatId,
+            isGroup: envelope.isGroup
+          },
+          ...this.atSender && envelope.isGroup ? {
+            sender: {
+              senderName: envelope.senderName
+            }
+          } : {}
+        });
+        if (this.inboundCardOwners.size > 1e3) {
+          const oldest = this.inboundCardOwners.keys().next().value;
+          if (oldest !== void 0)
+            this.inboundCardOwners.delete(oldest);
+        }
       }
-    }
-    const atUserId = envelope[mentionTarget];
-    if (this.atSender && messageId && atUserId) {
-      this.mentionTargets.set(messageId, atUserId);
-    }
-    await this.processInbound(envelope);
+      const atUserId = envelope[mentionTarget];
+      if (this.atSender && messageId && atUserId) {
+        this.mentionTargets.set(messageId, atUserId);
+      }
+      await this.processInbound(envelope);
+    });
   }
   async processInbound(envelope) {
     const messageId = envelope.messageId;
@@ -8704,36 +8935,123 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
       this.bufferedMentionTargetsBySession.delete(sessionId);
   }
   onPromptEnd(chatId, sessionId, messageId) {
+    this.settleBlockFileProjector(chatId, sessionId);
     this.sessionMentionTargets.delete(sessionId);
     this.stopReaction(chatId, messageId, sessionId);
   }
-  async sendResponseMessage(chatId, text, sessionId) {
-    const atUserId = this.atSender ? this.sessionMentionTargets.get(sessionId) : void 0;
+  /**
+   * Turn end is the only point where the block projector's held state can be
+   * settled: ChannelBase drains the turn's queued block sends before calling
+   * onPromptEnd, so everything already appended belongs to this turn. Flush
+   * the held candidate bytes (a trailing `[FILE:` prefix the stream never
+   * completed) before deleting the entry — a later delete-without-settle
+   * would silently drop them from the delivered answer. Also disarm the
+   * session: /clear eviction and session death settle WITHOUT draining the
+   * turn's send chain, and any block that lands afterwards must be dropped
+   * rather than recreating projector state.
+   */
+  settleBlockFileProjector(chatId, sessionId) {
+    this.blockProjectionArmed.delete(sessionId);
+    const state = this.blockFileProjectors.get(sessionId);
+    if (!state)
+      return;
+    this.blockFileProjectors.delete(sessionId);
+    const tail = state.projector.complete();
+    if (!tail.trim())
+      return;
+    void this.sendReply(chatId, tail, void 0, this.getResponseSourceLabel(sessionId)).catch((err) => {
+      process.stderr.write(`[DingTalk:${this.name}] projector tail delivery failed for session ${sessionId}: ${err instanceof Error ? err.message : String(err)}
+`);
+    });
+  }
+  /**
+   * Out-of-turn one-shot sends (background responses) must not flow through
+   * the session's block-streaming projector: a second sender interleaving with
+   * mid-projection state can swallow the send or split a held marker.
+   */
+  async deliverBackgroundReply(chatId, text, sessionId, sourceLabel) {
+    if (this.config.blockStreaming !== "on") {
+      return super.deliverBackgroundReply(chatId, text, sessionId, sourceLabel);
+    }
+    await this.sendReply(chatId, text, void 0, sourceLabel);
+  }
+  async sendResponseMessage(chatId, text, sessionId, sourceLabel) {
+    let outgoingText = text;
+    let consumesMention = true;
+    if (this.config.blockStreaming === "on") {
+      const projected = this.projectBlockStreamChunk(text, sessionId);
+      if (!projected.text.trim())
+        return;
+      outgoingText = projected.text;
+      consumesMention = projected.hasContent;
+    }
+    const atUserId = consumesMention && this.atSender ? this.sessionMentionTargets.get(sessionId) : void 0;
     if (atUserId)
       this.sessionMentionTargets.delete(sessionId);
-    await this.sendReply(chatId, text, atUserId);
+    await this.sendReply(chatId, outgoingText, atUserId, sourceLabel ?? this.getResponseSourceLabel(sessionId));
+  }
+  projectBlockStreamChunk(text, sessionId) {
+    let state = this.blockFileProjectors.get(sessionId);
+    if (!state) {
+      if (!this.blockProjectionArmed.has(sessionId)) {
+        return { text: "", hasContent: false };
+      }
+      state = { projector: new OutboundFileProjector(), reportedMarkers: 0 };
+      this.blockFileProjectors.set(sessionId, state);
+    }
+    const safe = state.projector.append(text);
+    const hasContent = safe.trim().length > 0;
+    const result = state.projector.result(safe);
+    let outgoingText = safe;
+    if (result.markerCount > state.reportedMarkers) {
+      outgoingText = withFileUnavailableNotice(safe);
+      state.reportedMarkers = result.markerCount;
+      process.stderr.write(`[DingTalk:${this.name}] file markers redacted in block stream (session ${sessionId}, markers=${result.markerCount})
+`);
+    }
+    return { text: outgoingText, hasContent };
   }
-  async sendFallbackReply(chatId, text, sessionId) {
+  async sendFallbackReply(chatId, text, sessionId, sourceLabel) {
     const atUserId = this.atSender ? this.sessionMentionTargets.get(sessionId) : void 0;
-    await this.sendReply(chatId, text, atUserId);
+    await this.sendReply(chatId, text, atUserId, sourceLabel);
   }
   async onResponseComplete(chatId, text, sessionId, segment) {
+    const streamed = segment ? this.fileProjectors.get(segment.runId)?.projector : void 0;
+    if (segment)
+      this.fileProjectors.delete(segment.runId);
+    const outgoingText = await this.prepareOutgoingText(text, streamed);
     if (segment && this.interactionPresenter) {
-      const outgoingText = await this.prepareOutgoingText(text);
       if (await this.interactionPresenter.closeOutput(segment.segmentId, outgoingText, "completed", segment)) {
         return;
       }
     }
-    await this.sendResponseMessage(chatId, text, sessionId);
+    await this.sendResponseMessage(chatId, outgoingText, sessionId, segment?.sourceLabel);
   }
   onOutputSegmentEnd(_chatId, _sessionId, segment, reason) {
+    if (reason === "completed" || reason === "failed" || reason === "cancelled") {
+      this.fileProjectors.delete(segment.runId);
+    }
     if (!this.interactionPresenter)
       return;
     return this.interactionPresenter.closeOutput(segment.segmentId, "", reason, segment).then(() => void 0);
   }
   onResponseChunk(_chatId, chunk, _sessionId, segment) {
-    if (segment)
-      this.interactionPresenter?.appendOutput(segment, chunk);
+    if (!segment)
+      return;
+    let state = this.fileProjectors.get(segment.runId);
+    if (!state) {
+      state = {
+        sessionId: segment.sessionId,
+        projector: new OutboundFileProjector()
+      };
+      this.fileProjectors.set(segment.runId, state);
+    }
+    const safe = state.projector.append(chunk);
+    if (safe)
+      this.interactionPresenter?.appendOutput(segment, safe);
+  }
+  deleteFileProjectorsForRun(runId) {
+    this.fileProjectors.delete(runId);
   }
   async presentUserInputRequest(context) {
     const run = this.cardRuns.get(context.runId);
@@ -8958,8 +9276,7 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
     const media = await downloadMedia(downloadCode, robotCode, token);
     if (!media)
       return;
-    const inlineImageSlotFree = !(envelope.attachments || []).some((attachment) => attachment.type === "image" && attachment.data);
-    if (mediaType === "image" && inlineImageSlotFree) {
+    if (mediaType === "image") {
       const mimeType = media.mimeType.startsWith("image/") ? media.mimeType : "image/jpeg";
       envelope.attachments = [
         ...envelope.attachments || [],
@@ -9069,19 +9386,22 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
       if (this.atSender && isGroup && senderStaffId) {
         envelope[mentionTarget] = senderStaffId;
       }
-      const processMessage = /* @__PURE__ */ __name(async () => {
+      const processMessage = content.downloadCodes.length > 0 || quoted.media ? this.prepareThenHandleInbound(envelope, async () => {
         if (content.downloadCodes.length > 0 && content.mediaType) {
-          await this.attachMedia(envelope, content.downloadCodes[0], content.mediaType, content.fileName, content.placeholder);
+          for (const downloadCode of content.downloadCodes) {
+            await this.attachMedia(envelope, downloadCode, content.mediaType, content.fileName, content.placeholder);
+          }
         }
         if (quoted.media) {
           await this.attachMedia(envelope, quoted.media.downloadCode, quoted.media.mediaType, quoted.media.fileName);
         }
-        await this.handleInbound(envelope);
-      }, "processMessage");
-      processMessage().catch((err) => {
+      }) : this.handleInbound(envelope);
+      processMessage.catch((err) => {
         process.stderr.write(`[DingTalk:${this.name}] Error handling message: ${err}
 `);
-        this.sendMessage(chatId, "Sorry, something went wrong processing your message.").catch(() => {
+        const sourceLabel = this.getInboundErrorSourceLabel(envelope);
+        const delivery = sourceLabel ? this.sendThreadMessage(chatId, envelope.threadId, "Sorry, something went wrong processing your message.", sourceLabel) : this.sendMessage(chatId, "Sorry, something went wrong processing your message.");
+        delivery.catch(() => {
         });
       });
     } catch (err) {