@qwen-code/qwen-code 0.22.0 → 0.22.2-nightly.20260828.7357136dd1

package/chunks/{dist-ES6HNUW2.js → dist-5VXFRTWU.js}

@@ -11,8 +11,10 @@ import {
   ChannelBase,
   isTerminalTaskLifecycleType,
   sanitizeLogText,
-  sanitizeSenderName
-} from "./chunk-AW27A43Y.js";
+  sanitizePromptText,
+  sanitizeSenderName,
+  truncateUtf16Units
+} from "./chunk-ICURCKIU.js";
 import "./chunk-IW6RQPQB.js";
 import "./chunk-CQ35AJ4Z.js";
 import "./chunk-DMTGGOSA.js";
@@ -6152,6 +6154,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;
@@ -7670,6 +7775,201 @@ var DingtalkInteractionPresenter = class {
 };
 
 // packages/channels/dingtalk/dist/DingtalkAdapter.js
+function nonEmptyString(value) {
+  if (typeof value !== "string")
+    return void 0;
+  const trimmed = value.trim();
+  return trimmed || void 0;
+}
+__name(nonEmptyString, "nonEmptyString");
+function parseJsonArray(value) {
+  if (Array.isArray(value))
+    return value;
+  if (typeof value !== "string")
+    return void 0;
+  try {
+    const parsed = JSON.parse(value);
+    return Array.isArray(parsed) ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+__name(parseJsonArray, "parseJsonArray");
+function sanitizeChatRecordField(value) {
+  return sanitizePromptText(value).trim();
+}
+__name(sanitizeChatRecordField, "sanitizeChatRecordField");
+function bracketSafeChatRecordField(value) {
+  return sanitizeChatRecordField(value).replace(/[[\]]/g, " ").trim();
+}
+__name(bracketSafeChatRecordField, "bracketSafeChatRecordField");
+function startOfLineSafeChatRecordField(value) {
+  const sanitized = sanitizeChatRecordField(value);
+  if (!sanitized.startsWith("["))
+    return sanitized;
+  const deleted = new Uint8Array(sanitized.length);
+  let open = 0;
+  let close = 0;
+  for (; ; ) {
+    while (open < sanitized.length && (deleted[open] === 1 || /\s/.test(sanitized[open]))) {
+      open += 1;
+    }
+    if (sanitized[open] !== "[")
+      break;
+    let next = Math.max(close, open + 1);
+    while (next < sanitized.length && (deleted[next] === 1 || sanitized[next] !== "]")) {
+      next += 1;
+    }
+    if (next >= sanitized.length) {
+      deleted[open] = 1;
+      open += 1;
+      close = next;
+      continue;
+    }
+    deleted[open] = 1;
+    deleted[next] = 1;
+    open += 1;
+    close = next + 1;
+  }
+  const parts = [];
+  let cut = 0;
+  for (let i = 0; i < sanitized.length; i++) {
+    if (deleted[i] === 0)
+      continue;
+    if (i > cut)
+      parts.push(sanitized.slice(cut, i));
+    cut = i + 1;
+  }
+  parts.push(sanitized.slice(cut));
+  return parts.join("").trim();
+}
+__name(startOfLineSafeChatRecordField, "startOfLineSafeChatRecordField");
+var MAX_CHAT_RECORD_ENTRIES = 50;
+var MAX_CHAT_RECORD_CHARS = 4e3;
+var MAX_CHAT_RECORD_LINE_CHARS = 500;
+var MAX_QUOTED_CHAT_RECORD_CHARS = 500;
+var CHAT_RECORD_ENTRIES_LABEL = "[Chat record messages]";
+var CHAT_RECORD_HEADER_LEAD = /* @__PURE__ */ __name((title) => `[Chat record: ${title}] `, "CHAT_RECORD_HEADER_LEAD");
+var CHAT_RECORD_PART_GAP = 2;
+function announcedDrop(count) {
+  return `[${count} more message(s) not shown]`;
+}
+__name(announcedDrop, "announcedDrop");
+function chatRecordAnnouncementCost(lines) {
+  return lines.length > 0 ? announcedDrop(lines.length).length + 1 : 0;
+}
+__name(chatRecordAnnouncementCost, "chatRecordAnnouncementCost");
+function capChatRecordLines(lines, budget) {
+  const kept = [];
+  let dropped = 0;
+  let total = 0;
+  const spendable = budget - chatRecordAnnouncementCost(lines);
+  if (spendable < 0)
+    return [];
+  for (const [index, line] of lines.entries()) {
+    if (kept.length >= MAX_CHAT_RECORD_ENTRIES) {
+      dropped = lines.length - index;
+      break;
+    }
+    const boundedRaw = truncateUtf16Units(line, MAX_CHAT_RECORD_LINE_CHARS);
+    const bounded = boundedRaw === line ? line : `${boundedRaw} [truncated]`;
+    if (total + bounded.length > spendable) {
+      dropped = lines.length - index;
+      break;
+    }
+    kept.push(bounded);
+    total += bounded.length + 1;
+  }
+  if (dropped > 0)
+    kept.push(announcedDrop(dropped));
+  return kept;
+}
+__name(capChatRecordLines, "capChatRecordLines");
+function mediaTypePlaceholder(msgType, fileName) {
+  switch (msgType) {
+    case "picture":
+      return "[image]";
+    case "file": {
+      const name = bracketSafeChatRecordField(nonEmptyString(fileName) || "");
+      return `[file: ${name || "file"}]`;
+    }
+    case "audio":
+      return "[audio]";
+    case "video":
+      return "[video]";
+    default:
+      return void 0;
+  }
+}
+__name(mediaTypePlaceholder, "mediaTypePlaceholder");
+function formatChatRecordEntryBody(record) {
+  const rawContent = record["content"];
+  const content = rawContent && typeof rawContent === "object" ? rawContent : void 0;
+  const body = nonEmptyString(record["text"]) || nonEmptyString(rawContent) || nonEmptyString(content?.["text"]) || nonEmptyString(record["message"]) || nonEmptyString(record["body"]);
+  if (body)
+    return sanitizeChatRecordField(body) || "[message]";
+  const msgType = nonEmptyString(record["msgType"]) || nonEmptyString(record["msgtype"]);
+  const safeMsgType = msgType ? bracketSafeChatRecordField(msgType) : "";
+  return mediaTypePlaceholder(msgType, content?.["fileName"]) ?? // Record-specific fallback: name the type when DingTalk sends one we do
+  // not model, so the model sees *something* arrived rather than a gap.
+  // The name is record content like every other field here, so it is
+  // neutralized before it goes inside the brackets.
+  (safeMsgType ? `[${safeMsgType}]` : "[message]");
+}
+__name(formatChatRecordEntryBody, "formatChatRecordEntryBody");
+function describeChatRecordKeys(content) {
+  if (!content || typeof content !== "object")
+    return "none";
+  const keys = Object.keys(content);
+  return keys.length > 0 ? keys.join(",") : "none";
+}
+__name(describeChatRecordKeys, "describeChatRecordKeys");
+function formatChatRecord(content, budget = MAX_CHAT_RECORD_CHARS) {
+  const title = nonEmptyString(content?.title);
+  const rawSummary = nonEmptyString(content?.summary);
+  const parsedSummary = parseJsonArray(rawSummary);
+  const summaryLines = parsedSummary ? parsedSummary.map((item) => startOfLineSafeChatRecordField(nonEmptyString(item) || "") || "") : rawSummary?.split("\n").map((line) => startOfLineSafeChatRecordField(nonEmptyString(line) || "")) || [];
+  const rawEntries = content?.chatRecord ?? content?.records ?? content?.messages;
+  const entries = parseJsonArray(rawEntries);
+  const recordLines = Array.isArray(entries) ? entries.flatMap((entry, index) => {
+    if (typeof entry === "string") {
+      const body = nonEmptyString(entry);
+      if (!body)
+        return [];
+      return [`Unknown: ${formatChatRecordEntryBody({ text: body })}`];
+    }
+    if (!entry || typeof entry !== "object")
+      return [];
+    const record = entry;
+    const summarySender = summaryLines.length === entries.length ? nonEmptyString(summaryLines[index]?.match(/^([^:：]+)[:：]/)?.[1]) : void 0;
+    const rawSender = nonEmptyString(record["senderName"]) || nonEmptyString(record["senderNick"]) || nonEmptyString(record["sender"]) || summarySender || nonEmptyString(record["senderId"]);
+    const sender = rawSender && bracketSafeChatRecordField(rawSender) || "Unknown";
+    return [`${sender}: ${formatChatRecordEntryBody(record)}`];
+  }) : [];
+  const entriesFloor = recordLines.length > 0 ? CHAT_RECORD_ENTRIES_LABEL.length + 1 + chatRecordAnnouncementCost(recordLines) : 0;
+  const headerBudget = Math.max(budget - CHAT_RECORD_PART_GAP - entriesFloor, 0);
+  const summaryDisplayLines = summaryLines.filter(Boolean);
+  const safeTitle = title ? truncateUtf16Units(bracketSafeChatRecordField(title), Math.max(Math.min(MAX_CHAT_RECORD_LINE_CHARS, headerBudget - CHAT_RECORD_HEADER_LEAD("").length - chatRecordAnnouncementCost(summaryDisplayLines)), 0)) || void 0 : void 0;
+  const headerLead = CHAT_RECORD_HEADER_LEAD(safeTitle || "untitled");
+  const summary = capChatRecordLines(summaryDisplayLines, Math.max(headerBudget - headerLead.length, 0)).join("\n");
+  const parts = [];
+  if (summary) {
+    parts.push(`${headerLead}${summary}`);
+  } else if (safeTitle) {
+    parts.push(`[Chat record: ${safeTitle}]`);
+  }
+  const spent = parts.reduce((used, part) => used + part.length + CHAT_RECORD_PART_GAP, 0);
+  const boundedLines = capChatRecordLines(recordLines, Math.max(budget - spent - CHAT_RECORD_ENTRIES_LABEL.length - 1, 0));
+  if (boundedLines.length > 0) {
+    parts.push(`${CHAT_RECORD_ENTRIES_LABEL}
+${boundedLines.join("\n")}`);
+  }
+  return {
+    text: parts.join("\n\n"),
+    entriesDropped: rawEntries !== void 0 && recordLines.length === 0
+  };
+}
+__name(formatChatRecord, "formatChatRecord");
 var DEDUP_TTL_MS = 5 * 60 * 1e3;
 var ACK_REACTION_NAME = "\u{1F440}";
 var ACK_EMOTION_ID = "2659900";
@@ -7682,6 +7982,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",
@@ -7757,6 +8058,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;
@@ -8002,10 +8315,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";
@@ -8037,7 +8361,7 @@ 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) {
     const webhook = this.webhooks.get(chatId);
@@ -8063,11 +8387,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 : {};
@@ -8358,6 +8690,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);
@@ -8405,6 +8743,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") {
@@ -8447,6 +8786,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);
@@ -8461,32 +8801,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;
@@ -8507,36 +8849,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);
   }
+  /**
+   * 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).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) {
+    if (this.config.blockStreaming !== "on") {
+      return super.deliverBackgroundReply(chatId, text, sessionId);
+    }
+    await this.sendReply(chatId, text);
+  }
   async sendResponseMessage(chatId, text, sessionId) {
-    const atUserId = this.atSender ? this.sessionMentionTargets.get(sessionId) : void 0;
+    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);
+  }
+  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) {
     const atUserId = this.atSender ? this.sessionMentionTargets.get(sessionId) : void 0;
     await this.sendReply(chatId, text, atUserId);
   }
   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);
   }
   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);
@@ -8580,8 +9009,32 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
     return { isReplyToBot: false };
   }
   /**
-   * Build a text summary from a repliedMsg, handling text, richText, and
-   * media message types with placeholders.
+   * Warn once when a chat-record payload yields nothing to show the model.
+   * Both chat-record paths degrade silently otherwise — `parseJsonArray`
+   * swallows JSON errors, the top-level path falls back to `(chat record)`
+   * and the replied path to an empty quote — matching this file's convention
+   * of logging degraded paths (`onDownStream`, `onMessage`).
+   */
+  warnEmptyChatRecord(content) {
+    process.stderr.write(`[DingTalk:${this.name}] chat record had no readable content (content keys: ${sanitizeLogText(describeChatRecordKeys(content), 200)})
+`);
+  }
+  /**
+   * The partial degradation the empty-record warning cannot see: a title or
+   * summary rendered, so the result is non-empty, but the entries key that
+   * arrived produced no lines at all (an object encoding such as
+   * `{"list":[...]}`, a non-array, or a present-but-unusable first alias).
+   * Every forwarded message is dropped and the user reports only that "the bot
+   * cannot see forwarded messages"; without this line nothing in the log
+   * distinguishes that from model behaviour.
+   */
+  warnUnreadableChatRecordEntries(content) {
+    process.stderr.write(`[DingTalk:${this.name}] chat record summary rendered but no readable entries (content keys: ${sanitizeLogText(describeChatRecordKeys(content), 200)})
+`);
+  }
+  /**
+   * Build a text summary from a repliedMsg, handling text, richText, chat
+   * records, and media message types with placeholders.
    */
   summarizeRepliedContent(replied) {
     const msgType = replied.msgType;
@@ -8605,19 +9058,15 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
       if (summary)
         return summary;
     }
-    switch (msgType) {
-      case "picture":
-        return "[image]";
-      case "file":
-        return `[file: ${content?.fileName || "file"}]`;
-      case "audio":
-        return "[audio]";
-      case "video":
-        return "[video]";
-      default:
-        break;
+    if (msgType === "chatRecord") {
+      const { text, entriesDropped } = formatChatRecord(content, MAX_QUOTED_CHAT_RECORD_CHARS);
+      if (!text)
+        this.warnEmptyChatRecord(content);
+      else if (entriesDropped)
+        this.warnUnreadableChatRecordEntries(content);
+      return text;
     }
-    return "";
+    return mediaTypePlaceholder(msgType, content?.fileName) ?? "";
   }
   /**
    * Map a DingTalk message type to the media type used for downloads. Shared
@@ -8634,7 +9083,8 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
   }
   /**
    * Extract text and media download codes from an incoming DingTalk message.
-   * Handles text, richText, picture, file, audio, and video message types.
+   * Handles text, richText, chat records, picture, file, audio, and video
+   * message types.
    */
   extractContent(data) {
     const msgtype = data.msgtype || "text";
@@ -8698,6 +9148,17 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
         placeholder: "(video)"
       };
     }
+    if (msgtype === "chatRecord") {
+      const { text, entriesDropped } = formatChatRecord(data.content);
+      if (!text)
+        this.warnEmptyChatRecord(data.content);
+      else if (entriesDropped)
+        this.warnUnreadableChatRecordEntries(data.content);
+      return {
+        text: text || "(chat record)",
+        downloadCodes: []
+      };
+    }
     return { text: data.text?.content?.trim() || "", downloadCodes: [] };
   }
   /**
@@ -8729,8 +9190,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 || [],
@@ -8840,16 +9300,17 @@ 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(() => {