@qwen-code/qwen-code 0.22.2-preview.1 → 0.22.3

package/chunks/{display-image-6KHQNEAE.js → display-image-BE7I6ZB6.js}

@@ -2,22 +2,22 @@
 "use strict";
 import {
   isInForkExecution
-} from "./chunk-7OBH4AM2.js";
-import "./chunk-OT4YKUUV.js";
+} from "./chunk-CAJTKR6W.js";
+import "./chunk-ZU4UDIWX.js";
 import "./chunk-AQ37AY7B.js";
-import "./chunk-RRKNX553.js";
+import "./chunk-PDQGMSZK.js";
 import {
   BaseDeclarativeTool,
   BaseToolInvocation,
   MAX_TERMINAL_IMAGE_BYTES,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-KOJ6MHD5.js";
+} from "./chunk-UTLCH2FK.js";
 import {
   makeRelative,
   shortenPath,
   unescapePath
-} from "./chunk-2NNTE2ED.js";
+} from "./chunk-UHQFIS7N.js";
 import "./chunk-TBWQLLFO.js";
 import {
   init_esbuild_shims

package/chunks/{dist-DJBNNPLN.js → dist-4WXLCBDR.js}

@@ -6,7 +6,7 @@ import {
 import "./chunk-7E7UCJHS.js";
 import {
   PollingChannelBase
-} from "./chunk-E55H6BZ7.js";
+} from "./chunk-ICURCKIU.js";
 import "./chunk-IW6RQPQB.js";
 import {
   external_exports

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

@@ -14,7 +14,7 @@ import {
   sanitizePromptText,
   sanitizeSenderName,
   truncateUtf16Units
-} from "./chunk-E55H6BZ7.js";
+} from "./chunk-ICURCKIU.js";
 import "./chunk-IW6RQPQB.js";
 import "./chunk-CQ35AJ4Z.js";
 import "./chunk-DMTGGOSA.js";
@@ -6154,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;
@@ -7879,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",
@@ -7954,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;
@@ -8199,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";
@@ -8234,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);
@@ -8260,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 : {};
@@ -8555,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);
@@ -8602,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") {
@@ -8644,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);
@@ -8658,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;
@@ -8704,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);
@@ -8958,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 || [],
@@ -9069,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(() => {