@qwen-code/qwen-code 0.22.3 → 0.23.0

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

@@ -4,9 +4,9 @@ import {
   require_dist,
   require_follow_redirects,
   require_form_data
-} from "./chunk-XIQ5HQ2F.js";
+} from "./chunk-OBTWL6ZW.js";
 import "./chunk-K6KS3LTN.js";
-import "./chunk-7E7UCJHS.js";
+import "./chunk-OSHQMOBS.js";
 import {
   ChannelBase,
   isTerminalTaskLifecycleType,
@@ -14,14 +14,14 @@ import {
   sanitizePromptText,
   sanitizeSenderName,
   truncateUtf16Units
-} from "./chunk-ICURCKIU.js";
+} from "./chunk-U4DJ5XB3.js";
 import "./chunk-IW6RQPQB.js";
 import "./chunk-CQ35AJ4Z.js";
 import "./chunk-DMTGGOSA.js";
 import "./chunk-YQ3U5MUC.js";
 import {
   wrapper_default
-} from "./chunk-J3NNHTV6.js";
+} from "./chunk-J5TTWBZK.js";
 import "./chunk-RVIGZBIT.js";
 import {
   init_esbuild_shims
@@ -39,8 +39,8 @@ init_esbuild_shims();
 init_esbuild_shims();
 import { mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { randomUUID as randomUUID5 } from "node:crypto";
-import { basename as basename2, join } from "node:path";
-import { tmpdir as tmpdir2 } from "node:os";
+import { basename as basename3, join } from "node:path";
+import { tmpdir as tmpdir3 } from "node:os";
 import { Buffer as Buffer2 } from "node:buffer";
 
 // node_modules/dingtalk-stream-sdk-nodejs/dist/index.mjs
@@ -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");
 
@@ -6156,8 +6177,15 @@ __name(uploadDingTalkImage, "uploadDingTalkImage");
 
 // packages/channels/dingtalk/dist/outbound-file.js
 init_esbuild_shims();
+import { closeSync as closeSync2, constants, fstatSync as fstatSync2, openSync as openSync2, readSync as readSync2, realpathSync as realpathSync2, statSync } from "node:fs";
+import { tmpdir as tmpdir2 } from "node:os";
+import { basename as basename2, extname as extname2, isAbsolute as isAbsolute2, relative as relative2, sep } from "node:path";
 var FILE_OPENING = "[FILE:";
+var MEDIA_UPLOAD_API2 = "https://oapi.dingtalk.com/media/upload";
+var MEDIA_UPLOAD_TIMEOUT_MS2 = 3e4;
 var MAX_FILE_PATH_CHARS = 4096;
+var MAX_FILE_BYTES = 20 * 1024 * 1024;
+var AUTH_ERROR_CODES2 = /* @__PURE__ */ new Set([40014, 42001]);
 var MAX_FILES_PER_RESPONSE = 5;
 var FILE_UNAVAILABLE_NOTICE = "[File delivery unavailable]";
 var OutboundFileProjector = class {
@@ -6256,6 +6284,104 @@ function withFileUnavailableNotice(text) {
   return `${safe}${safe ? "\n" : ""}${FILE_UNAVAILABLE_NOTICE}`;
 }
 __name(withFileUnavailableNotice, "withFileUnavailableNotice");
+function safeFileName(filePath) {
+  return basename2(filePath).replace(/[\p{Cc}\p{Cf}[\]]+/gu, "_").slice(0, 200) || "file";
+}
+__name(safeFileName, "safeFileName");
+function isInside2(filePath, directory) {
+  const child = relative2(directory, filePath);
+  return child === "" || !isAbsolute2(child) && child !== ".." && !child.startsWith(`..${sep}`);
+}
+__name(isInside2, "isInside");
+function readValidatedFile(filePath, workspaceDir) {
+  if (!isAbsolute2(filePath))
+    throw new Error("File path must be absolute");
+  let realPath;
+  try {
+    realPath = realpathSync2(filePath);
+  } catch {
+    throw new Error("File not found");
+  }
+  const roots = [
+    workspaceDir,
+    tmpdir2(),
+    ...process.platform === "win32" ? [] : ["/tmp"]
+  ].map((root) => realpathSync2(root));
+  if (!roots.some((root) => isInside2(realPath, root))) {
+    throw new Error("File path outside allowed directories");
+  }
+  if (!statSync(realPath).isFile())
+    throw new Error("Not a regular file");
+  const descriptor = openSync2(realPath, constants.O_RDONLY | constants.O_NONBLOCK | (constants.O_NOFOLLOW ?? 0));
+  try {
+    const stats = fstatSync2(descriptor);
+    if (!stats.isFile())
+      throw new Error("Not a regular file");
+    if (stats.size === 0)
+      throw new Error("File is empty");
+    if (stats.size > MAX_FILE_BYTES)
+      throw new Error("File is too large");
+    const data = Buffer.allocUnsafe(stats.size + 1);
+    let bytesRead = 0;
+    while (bytesRead < data.length) {
+      const count = readSync2(descriptor, data, bytesRead, data.length - bytesRead, bytesRead);
+      if (count === 0)
+        break;
+      bytesRead += count;
+    }
+    if (bytesRead !== stats.size)
+      throw new Error("File changed while read");
+    const fileName = safeFileName(realPath);
+    return {
+      data: data.subarray(0, bytesRead),
+      fileName,
+      fileType: extname2(fileName).slice(1).toLowerCase() || "file"
+    };
+  } finally {
+    closeSync2(descriptor);
+  }
+}
+__name(readValidatedFile, "readValidatedFile");
+function sanitizeApiMessage2(message, accessToken) {
+  const value = String(message ?? "");
+  return (accessToken ? value.replaceAll(accessToken, "[redacted]") : value).replace(/[\r\n\t]+/g, " ").slice(0, 200);
+}
+__name(sanitizeApiMessage2, "sanitizeApiMessage");
+async function uploadDingTalkFile(file, accessToken) {
+  const form = new FormData();
+  form.append("media", new Blob([file.data], { type: "application/octet-stream" }), file.fileName);
+  let response;
+  try {
+    const url2 = new URL(MEDIA_UPLOAD_API2);
+    url2.searchParams.set("access_token", accessToken);
+    url2.searchParams.set("type", "file");
+    response = await fetch(url2, {
+      method: "POST",
+      body: form,
+      signal: AbortSignal.timeout(MEDIA_UPLOAD_TIMEOUT_MS2)
+    });
+  } catch {
+    throw new DingTalkMediaUploadError("DingTalk file upload failed: network request failed", false);
+  }
+  let payload;
+  try {
+    const parsed = await response.json();
+    payload = parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    throw new DingTalkMediaUploadError(`DingTalk file upload failed: HTTP ${response.status} invalid JSON response`, response.status === 401);
+  }
+  const errcode = typeof payload["errcode"] === "number" ? payload["errcode"] : void 0;
+  if (!response.ok || errcode !== void 0 && errcode !== 0) {
+    const detail = sanitizeApiMessage2(payload["errmsg"], accessToken);
+    throw new DingTalkMediaUploadError(`DingTalk file upload failed: HTTP ${response.status}${errcode === void 0 ? "" : ` errcode=${errcode}`}${detail ? ` ${detail}` : ""}`, response.status === 401 || errcode !== void 0 && AUTH_ERROR_CODES2.has(errcode));
+  }
+  const mediaId = typeof payload["media_id"] === "string" ? payload["media_id"] : typeof payload["mediaId"] === "string" ? payload["mediaId"] : void 0;
+  if (!mediaId) {
+    throw new DingTalkMediaUploadError("DingTalk file upload failed: response did not include a MediaID", false);
+  }
+  return mediaId;
+}
+__name(uploadDingTalkFile, "uploadDingTalkFile");
 
 // packages/channels/dingtalk/dist/DingtalkConnectionManager.js
 init_esbuild_shims();
@@ -6569,6 +6695,25 @@ var STATUS_CARD_TEMPLATE_ID = "675cde2f-f526-40cb-b828-f5b2b57b8b77.schema";
 var QUESTION_CARD_TEMPLATE_ID = "c2a6355b-9724-4f7e-9653-d33fcb3311bb.schema";
 var DINGTALK_API = "https://api.dingtalk.com";
 var CARD_FETCH_TIMEOUT_MS = 1e4;
+function isRetryableStatus(status) {
+  return status === 408 || status === 425 || status === 429 || status >= 500 && status <= 599;
+}
+__name(isRetryableStatus, "isRetryableStatus");
+var DingtalkCardRequestError = class extends Error {
+  static {
+    __name(this, "DingtalkCardRequestError");
+  }
+  retryable;
+  constructor(message, retryable) {
+    super(message);
+    this.retryable = retryable;
+    this.name = "DingtalkCardRequestError";
+  }
+};
+function isRetryableDingtalkCardError(error) {
+  return !(error instanceof DingtalkCardRequestError) || error.retryable;
+}
+__name(isRetryableDingtalkCardError, "isRetryableDingtalkCardError");
 function stringifyCardParamMap(cardParamMap) {
   return Object.fromEntries(Object.entries(cardParamMap).map(([key, value]) => [
     key,
@@ -6617,7 +6762,7 @@ var DingtalkInteractiveCardClient = class {
     if (Array.isArray(deliveries)) {
       const failure = deliveries.find((entry) => entry !== null && typeof entry === "object" && entry.success === false);
       if (failure) {
-        throw new Error(`${input.templateId}: ${typeof failure.errorMsg === "string" && failure.errorMsg.trim() ? failure.errorMsg.trim() : "DingTalk card delivery failed"}`);
+        throw new DingtalkCardRequestError(`${input.templateId}: ${typeof failure.errorMsg === "string" && failure.errorMsg.trim() ? failure.errorMsg.trim() : "DingTalk card delivery failed"}`, false);
       }
     }
   }
@@ -6642,21 +6787,28 @@ var DingtalkInteractiveCardClient = class {
     });
   }
   async request(path, method, body, templateId) {
-    const token = await this.options.getAccessToken();
-    const response = await this.fetch(`${DINGTALK_API}${path}`, {
-      method,
-      headers: {
-        "Content-Type": "application/json",
-        "x-acs-dingtalk-access-token": token
-      },
-      body: JSON.stringify(body),
-      signal: AbortSignal.timeout(CARD_FETCH_TIMEOUT_MS)
-    });
-    if (!response.ok) {
-      const detail = (await response.text().catch(() => "")).slice(0, 300);
-      throw new Error(`DingTalk Card OpenAPI ${method} ${path} failed${templateId ? ` for ${templateId}` : ""}: HTTP ${response.status}${detail ? ` ${detail}` : ""}`);
+    for (let attempt = 0; ; attempt++) {
+      const token = await this.options.getAccessToken();
+      const response = await this.fetch(`${DINGTALK_API}${path}`, {
+        method,
+        headers: {
+          "Content-Type": "application/json",
+          "x-acs-dingtalk-access-token": token
+        },
+        body: JSON.stringify(body),
+        signal: AbortSignal.timeout(CARD_FETCH_TIMEOUT_MS)
+      });
+      if (response.status === 401 && attempt === 0) {
+        this.options.invalidateAccessToken(token);
+        await response.body?.cancel();
+        continue;
+      }
+      if (!response.ok) {
+        const detail = (await response.text().catch(() => "")).slice(0, 300);
+        throw new DingtalkCardRequestError(`DingTalk Card OpenAPI ${method} ${path} failed${templateId ? ` for ${templateId}` : ""}: HTTP ${response.status}${detail ? ` ${detail}` : ""}`, isRetryableStatus(response.status));
+      }
+      return response.json().catch(() => void 0);
     }
-    return response.json().catch(() => void 0);
   }
 };
 
@@ -6783,8 +6935,11 @@ init_esbuild_shims();
 import { randomUUID as randomUUID2 } from "node:crypto";
 var FLUSH_INTERVAL_MS = 500;
 var STATUS_REFRESH_INTERVAL_MS = 1e3;
+var CONTENT_SYNC_INTERVAL_SECONDS = 5;
 var BREAKER_PROBE_INTERVAL_MS = 3e4;
 var MAX_CONSECUTIVE_STATUS_FAILURES = 3;
+var INITIAL_RETRY_INTERVAL_MS = 1e3;
+var MAX_RETRY_INTERVAL_MS = 3e4;
 var CONTENT_LIMIT = 2e4;
 var TRUNCATION_MARKER = "[Earlier output truncated]\n";
 function boundContent(content) {
@@ -6802,10 +6957,13 @@ var StatusCardController = class {
   recordsByOutTrack = /* @__PURE__ */ new Map();
   segmentIdsByRun = /* @__PURE__ */ new Map();
   terminalSegmentIds = /* @__PURE__ */ new Set();
+  disposed = false;
   constructor(options) {
     this.options = options;
   }
   ensure(segment, target) {
+    if (this.disposed)
+      return;
     if (this.terminalSegmentIds.has(segment.segmentId))
       return;
     if (!this.recordsBySegment.has(segment.segmentId)) {
@@ -6813,6 +6971,8 @@ var StatusCardController = class {
     }
   }
   replace(segment, target, content) {
+    if (this.disposed)
+      return;
     if (this.terminalSegmentIds.has(segment.segmentId))
       return;
     const record = this.recordsBySegment.get(segment.segmentId);
@@ -6823,22 +6983,27 @@ var StatusCardController = class {
     if (record.terminal)
       return;
     record.content = boundContent(content);
+    record.contentVersion++;
     if (record.streamFailed)
       return;
-    record.pendingSnapshot = sanitizeStreamingImageMarkers(record.content);
+    record.hasPendingWrite = true;
     this.scheduleFlush(record);
   }
   /**
    * Whether a created, still-running status card is displaying content for
    * this segment. Awaits the in-flight creation so a boundary decision made
    * while creation is pending does not race it. A latched stream failure
-   * means the card can never show further content, so it is not live.
+   * means the card can never show further content, so it is not live. A
+   * creation that is backing off for a retry is not awaited either (see
+   * `awaitDelivery`).
    */
   async isCardLive(segmentId) {
+    if (this.disposed)
+      return false;
     const record = this.recordsBySegment.get(segmentId);
     if (!record || record.terminal || record.streamFailed)
       return false;
-    return record.ready;
+    return this.awaitDelivery(record);
   }
   /**
    * Drain any pending snapshot so callers can treat the card's current
@@ -6847,23 +7012,64 @@ var StatusCardController = class {
    * caller can fall back instead of claiming delivery.
    */
   async flushPending(segmentId) {
+    if (this.disposed)
+      return false;
     const record = this.recordsBySegment.get(segmentId);
     if (!record || record.terminal)
       return false;
-    if (!await record.ready)
+    if (!await this.awaitDelivery(record))
       return false;
     while (!record.terminal && !record.streamFailed) {
       if (record.flushTimer) {
         clearTimeout(record.flushTimer);
         record.flushTimer = void 0;
       }
+      if (record.streamRetryTimer) {
+        clearTimeout(record.streamRetryTimer);
+        record.streamRetryTimer = void 0;
+      }
+      const failureVersion = record.streamFailureVersion;
       this.flush(record);
       await record.writeChain;
-      if (record.pendingSnapshot === void 0)
+      if (record.streamFailureVersion !== failureVersion)
+        return false;
+      if (!record.hasPendingWrite)
         break;
     }
     return !record.terminal && !record.streamFailed;
   }
+  abandon(segmentId) {
+    const record = this.recordsBySegment.get(segmentId);
+    if (!record || record.terminal)
+      return;
+    record.terminal = true;
+    record.hasPendingWrite = false;
+    void record.ready.then((ready) => {
+      if (!ready)
+        return;
+      void this.options.client.updateInstance({
+        outTrackId: record.outTrackId,
+        cardParamMap: {
+          flowStatus: 3,
+          hasAction: "false",
+          stop_action: "false"
+        }
+      }).catch(() => {
+      });
+    });
+    this.removeRecord(record);
+  }
+  /**
+   * Resolves once the card is known to be delivered (or not) without waiting
+   * through a creation backoff: `creationAttempt` is the failed attempt until
+   * the retry actually starts, so a boundary reached mid-backoff falls back
+   * to text while the retry keeps running for later output.
+   */
+  async awaitDelivery(record) {
+    if (!await record.creationAttempt)
+      return false;
+    return record.ready;
+  }
   createRecord(segment, target, initialContent = "") {
     const outTrackId = `qwen-status-${randomUUID2()}`;
     const record = {
@@ -6876,13 +7082,21 @@ var StatusCardController = class {
       content: boundContent(initialContent),
       startedAt: Date.now(),
       lastStatusSecond: 0,
+      lastContentSyncSecond: 0,
       ready: Promise.resolve(false),
+      creationAttempt: Promise.resolve(false),
       terminal: false,
       streamFailed: false,
+      streamFailureVersion: 0,
+      createRetryAttempt: 0,
+      streamRetryAttempt: 0,
+      terminalRetryAttempt: 0,
       consecutiveStatusFailures: 0,
       stopClaimed: false,
       forbiddenActors: /* @__PURE__ */ new Set(),
       lastWriteAt: Date.now(),
+      contentVersion: 0,
+      hasPendingWrite: false,
       writeChain: Promise.resolve()
     };
     this.recordsBySegment.set(record.segmentId, record);
@@ -6904,6 +7118,8 @@ var StatusCardController = class {
     void this.finalize(segmentId, boundContent(error), "Failed", true);
   }
   cancelRun(runId, reason) {
+    if (this.disposed)
+      return;
     for (const segmentId of [...this.segmentIdsByRun.get(runId) ?? []]) {
       const record = this.recordsBySegment.get(segmentId);
       if (!record)
@@ -6912,6 +7128,8 @@ var StatusCardController = class {
     }
   }
   claimStop(outTrackId, actorId) {
+    if (this.disposed)
+      return { kind: "ignored", actorId };
     const record = this.recordsByOutTrack.get(outTrackId);
     if (!record || record.terminal || record.stopClaimed) {
       return { kind: "ignored", actorId };
@@ -6940,44 +7158,72 @@ var StatusCardController = class {
     };
   }
   async create(record, target) {
-    try {
-      const initialContent = sanitizeStreamingImageMarkers(record.content);
-      await this.options.client.createAndDeliver({
-        templateId: STATUS_CARD_TEMPLATE_ID,
-        outTrackId: record.outTrackId,
-        target,
-        cardParamMap: {
-          content: initialContent,
-          flowStatus: 2,
-          statusLine: this.statusLine(record, "Running").text,
-          hasAction: "true",
-          stop_action: "true"
-        }
+    for (; ; ) {
+      let settleAttempt;
+      record.creationAttempt = new Promise((resolve) => {
+        settleAttempt = resolve;
       });
+      try {
+        await this.options.client.createAndDeliver({
+          templateId: STATUS_CARD_TEMPLATE_ID,
+          outTrackId: record.outTrackId,
+          target,
+          cardParamMap: {
+            content: sanitizeStreamingImageMarkers(record.content),
+            flowStatus: 2,
+            statusLine: this.statusLine(record, "Running").text,
+            hasAction: "true",
+            stop_action: "true"
+          }
+        });
+        settleAttempt(true);
+        break;
+      } catch (error) {
+        settleAttempt(false);
+        this.options.onError?.("status card creation", error);
+        if (this.disposed || record.terminal || !isRetryableDingtalkCardError(error)) {
+          return false;
+        }
+        if (!await this.waitForCreationRetry(record))
+          return false;
+      }
+    }
+    if (this.disposed)
+      return false;
+    if (this.recordsBySegment.get(record.segmentId) !== record)
+      return true;
+    try {
       await this.options.client.openOrUpdateStream({
         outTrackId: record.outTrackId,
         key: "content",
-        content: initialContent,
+        content: sanitizeStreamingImageMarkers(record.content),
         finalize: false
       });
-      return true;
     } catch (error) {
-      this.options.onError?.("status card creation", error);
-      await this.options.client.updateInstance({
-        outTrackId: record.outTrackId,
-        cardParamMap: {
-          flowStatus: 3,
-          statusLine: "Unavailable",
-          hasAction: "false",
-          stop_action: "false"
-        }
-      }).catch(() => {
-      });
-      return false;
+      this.handleStreamFailure(record, error);
     }
+    return true;
+  }
+  /**
+   * Sleeps for the next creation backoff. Resolves false when finalization or
+   * disposal abandons the creation so `ready` settles without waiting.
+   */
+  waitForCreationRetry(record) {
+    const delay = this.retryDelay(record.createRetryAttempt++);
+    return new Promise((resolve) => {
+      const settle2 = /* @__PURE__ */ __name((resumed) => {
+        if (record.createRetryTimer)
+          clearTimeout(record.createRetryTimer);
+        record.createRetryTimer = void 0;
+        record.abandonCreation = void 0;
+        resolve(resumed);
+      }, "settle");
+      record.abandonCreation = () => settle2(false);
+      record.createRetryTimer = setTimeout(() => settle2(true), delay);
+    });
   }
   scheduleFlush(record) {
-    if (record.flushTimer || record.inFlight || record.terminal)
+    if (record.flushTimer || record.streamRetryTimer || record.inFlight || record.terminal)
       return;
     const delay = Math.max(0, FLUSH_INTERVAL_MS - (Date.now() - record.lastWriteAt));
     record.flushTimer = setTimeout(() => {
@@ -6986,42 +7232,44 @@ var StatusCardController = class {
     }, delay);
   }
   flush(record) {
-    if (record.terminal || record.inFlight || record.pendingSnapshot === void 0)
+    if (this.disposed || record.terminal || record.streamFailed || record.inFlight || !record.hasPendingWrite)
       return;
-    const content = record.pendingSnapshot;
-    record.pendingSnapshot = void 0;
+    record.hasPendingWrite = false;
+    let sentVersion;
+    let contentWritten = false;
     const write = record.writeChain.then(async () => {
       const ready = await record.ready;
-      if (!ready || record.terminal)
+      if (!ready || record.terminal || record.streamFailed)
         return;
+      sentVersion = record.contentVersion;
       await this.options.client.openOrUpdateStream({
         outTrackId: record.outTrackId,
         key: "content",
-        content,
+        content: sanitizeStreamingImageMarkers(record.content),
         finalize: false
       });
+      contentWritten = true;
+      record.streamRetryAttempt = 0;
       await this.updateRunningStatus(record);
-    }).catch((error) => {
-      record.streamFailed = true;
-      record.pendingSnapshot = void 0;
-      if (record.statusTimer) {
-        clearTimeout(record.statusTimer);
-        record.statusTimer = void 0;
-      }
-      this.options.onError?.("status card streaming", error);
-    });
+    }).catch((error) => this.handleStreamFailure(record, error));
     const tracked = write.finally(() => {
       if (record.inFlight === tracked) {
         record.inFlight = void 0;
       }
       record.lastWriteAt = Date.now();
-      if (record.pendingSnapshot !== void 0)
+      if (contentWritten && record.contentVersion === sentVersion) {
+        record.hasPendingWrite = false;
+      }
+      if (record.hasPendingWrite && record.contentVersion !== sentVersion) {
         this.scheduleFlush(record);
+      }
     });
     record.inFlight = tracked;
     record.writeChain = tracked;
   }
   async finalize(segmentId, content, state, isError, retainedContent) {
+    if (this.disposed)
+      return false;
     const record = this.recordsBySegment.get(segmentId);
     if (!record || record.terminal)
       return false;
@@ -7036,58 +7284,165 @@ var StatusCardController = class {
     if (record.flushTimer)
       clearTimeout(record.flushTimer);
     record.flushTimer = void 0;
+    if (record.streamRetryTimer)
+      clearTimeout(record.streamRetryTimer);
+    record.streamRetryTimer = void 0;
     if (record.statusTimer)
       clearTimeout(record.statusTimer);
     record.statusTimer = void 0;
-    record.pendingSnapshot = void 0;
+    record.hasPendingWrite = false;
+    record.abandonCreation?.();
+    if (!await record.ready) {
+      this.removeRecord(record);
+      return false;
+    }
+    await record.writeChain;
+    const retained = content || (retainedContent ? retainedContent(record.content) : record.content);
+    record.terminalIntent = {
+      content: boundContent(sanitizeStreamingImageMarkers(retained)),
+      isError,
+      statusLine: this.statusLine(record, state).text,
+      streamFinalizeSettled: false
+    };
+    return this.attemptFinalization(record);
+  }
+  async attemptFinalization(record) {
+    if (this.disposed)
+      return false;
+    if (this.recordsBySegment.get(record.segmentId) !== record)
+      return false;
+    const intent = record.terminalIntent;
+    if (!intent)
+      return false;
+    if (!intent.streamFinalizeSettled) {
+      try {
+        await this.options.client.openOrUpdateStream({
+          outTrackId: record.outTrackId,
+          key: "content",
+          content: "",
+          finalize: true,
+          isError: intent.isError
+        });
+        intent.streamFinalizeSettled = true;
+      } catch (error) {
+        if (!isRetryableDingtalkCardError(error)) {
+          intent.streamFinalizeSettled = true;
+        }
+        this.options.onError?.("status card finalization", error);
+      }
+    }
+    if (this.disposed)
+      return false;
     try {
-      if (!await record.ready)
-        return false;
-      await record.writeChain;
-      const retained = content || (retainedContent ? retainedContent(record.content) : record.content);
-      const finalContent = boundContent(sanitizeStreamingImageMarkers(retained));
-      await this.options.client.openOrUpdateStream({
-        outTrackId: record.outTrackId,
-        key: "content",
-        content: "",
-        finalize: true,
-        isError
-      });
       await this.options.client.updateInstance({
         outTrackId: record.outTrackId,
         cardParamMap: {
           blockList: JSON.stringify([
             {
               type: 0,
-              markdown: finalContent
+              markdown: intent.content
             }
           ]),
-          content: finalContent,
-          copy_content: finalContent,
+          content: intent.content,
+          copy_content: intent.content,
           flowStatus: 3,
-          statusLine: this.statusLine(record, state).text,
+          statusLine: intent.statusLine,
           hasAction: "false",
           stop_action: "false"
         }
       });
       record.content = "";
+      this.removeRecord(record);
       return true;
     } catch (error) {
       this.options.onError?.("status card finalization", error);
-      return false;
-    } finally {
-      if (this.recordsBySegment.get(segmentId) === record) {
-        this.recordsBySegment.delete(segmentId);
-      }
-      if (this.recordsByOutTrack.get(record.outTrackId) === record) {
-        this.recordsByOutTrack.delete(record.outTrackId);
+      if (isRetryableDingtalkCardError(error)) {
+        this.scheduleTerminalRetry(record);
+        return true;
+      } else {
+        this.removeRecord(record);
       }
-      const segmentIds = this.segmentIdsByRun.get(record.runId);
-      segmentIds?.delete(segmentId);
-      if (segmentIds?.size === 0) {
-        this.segmentIdsByRun.delete(record.runId);
+      return false;
+    }
+  }
+  scheduleStreamRetry(record) {
+    if (this.disposed || record.terminal || record.streamFailed || record.streamRetryTimer) {
+      return;
+    }
+    const delay = this.retryDelay(record.streamRetryAttempt++);
+    record.streamRetryTimer = setTimeout(() => {
+      record.streamRetryTimer = void 0;
+      if (this.disposed || record.terminal || record.streamFailed)
+        return;
+      this.flush(record);
+    }, delay);
+  }
+  scheduleTerminalRetry(record) {
+    if (this.disposed || !record.terminalIntent || record.terminalRetryTimer) {
+      return;
+    }
+    const delay = this.retryDelay(record.terminalRetryAttempt++);
+    record.terminalRetryTimer = setTimeout(() => {
+      record.terminalRetryTimer = void 0;
+      if (this.disposed)
+        return;
+      void this.attemptFinalization(record);
+    }, delay);
+  }
+  handleStreamFailure(record, error) {
+    record.streamFailureVersion++;
+    if (!this.disposed && !record.terminal && isRetryableDingtalkCardError(error)) {
+      record.hasPendingWrite = true;
+      this.scheduleStreamRetry(record);
+    } else if (!record.terminal) {
+      record.streamFailed = true;
+      record.hasPendingWrite = false;
+      if (record.statusTimer) {
+        clearTimeout(record.statusTimer);
+        record.statusTimer = void 0;
       }
     }
+    this.options.onError?.("status card streaming", error);
+  }
+  retryDelay(attempt) {
+    return Math.min(INITIAL_RETRY_INTERVAL_MS * 2 ** Math.min(attempt, 10), MAX_RETRY_INTERVAL_MS);
+  }
+  removeRecord(record) {
+    record.abandonCreation?.();
+    if (record.flushTimer)
+      clearTimeout(record.flushTimer);
+    if (record.streamRetryTimer)
+      clearTimeout(record.streamRetryTimer);
+    if (record.terminalRetryTimer)
+      clearTimeout(record.terminalRetryTimer);
+    if (record.statusTimer)
+      clearTimeout(record.statusTimer);
+    record.flushTimer = void 0;
+    record.streamRetryTimer = void 0;
+    record.terminalRetryTimer = void 0;
+    record.statusTimer = void 0;
+    if (this.recordsBySegment.get(record.segmentId) === record) {
+      this.recordsBySegment.delete(record.segmentId);
+    }
+    if (this.recordsByOutTrack.get(record.outTrackId) === record) {
+      this.recordsByOutTrack.delete(record.outTrackId);
+    }
+    const segmentIds = this.segmentIdsByRun.get(record.runId);
+    segmentIds?.delete(record.segmentId);
+    if (segmentIds?.size === 0) {
+      this.segmentIdsByRun.delete(record.runId);
+    }
+  }
+  dispose() {
+    if (this.disposed)
+      return;
+    this.disposed = true;
+    for (const record of [...this.recordsBySegment.values()]) {
+      record.terminal = true;
+      record.hasPendingWrite = false;
+      this.removeRecord(record);
+    }
+    this.terminalSegmentIds.clear();
   }
   statusLine(record, state) {
     const second = Math.max(0, Math.floor((Date.now() - record.startedAt) / 1e3));
@@ -7098,17 +7453,23 @@ var StatusCardController = class {
     };
   }
   async updateRunningStatus(record) {
-    if (record.terminal || record.streamFailed)
+    if (this.disposed || record.terminal || record.streamFailed)
       return;
     const status = this.statusLine(record, "Running");
     if (status.second === record.lastStatusSecond)
       return;
+    const syncContent = status.second - record.lastContentSyncSecond >= CONTENT_SYNC_INTERVAL_SECONDS;
     try {
       await this.options.client.updateInstance({
         outTrackId: record.outTrackId,
-        cardParamMap: { statusLine: status.text }
+        cardParamMap: {
+          ...syncContent ? { content: sanitizeStreamingImageMarkers(record.content) } : {},
+          statusLine: status.text
+        }
       });
       record.lastStatusSecond = status.second;
+      if (syncContent)
+        record.lastContentSyncSecond = status.second;
       record.consecutiveStatusFailures = 0;
       if (record.statusTimer) {
         clearTimeout(record.statusTimer);
@@ -7121,13 +7482,13 @@ var StatusCardController = class {
     }
   }
   scheduleStatusRefresh(record, intervalMs = STATUS_REFRESH_INTERVAL_MS) {
-    if (record.terminal || record.streamFailed || record.statusTimer)
+    if (this.disposed || record.terminal || record.streamFailed || record.statusTimer)
       return;
     const elapsed = Math.max(0, Date.now() - record.startedAt);
     const delay = Math.max(50, intervalMs - elapsed % intervalMs);
     record.statusTimer = setTimeout(() => {
       record.statusTimer = void 0;
-      if (record.terminal || record.streamFailed)
+      if (this.disposed || record.terminal || record.streamFailed)
         return;
       const refresh = record.writeChain.then(() => this.updateRunningStatus(record));
       record.writeChain = refresh;
@@ -7208,7 +7569,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);
       }
@@ -7350,22 +7711,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"
       }
     };
@@ -7374,7 +7735,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) {
@@ -7434,7 +7797,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: "",
@@ -7470,19 +7833,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}`
   };
 }
@@ -7498,7 +7869,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,
@@ -7514,10 +7885,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
     });
   }
@@ -7529,7 +7902,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) {
@@ -7550,7 +7923,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) {
@@ -7594,7 +7967,8 @@ 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);
+        statusCards?.abandon(statusContext.segmentId);
         return true;
       }
       if (reason === "input_requested") {
@@ -7605,7 +7979,8 @@ 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);
+        statusCards?.abandon(statusContext.segmentId);
         return true;
       }
       statusCards?.ensure(statusContext, this.cardTarget(statusContext.target));
@@ -7615,7 +7990,8 @@ 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);
+      statusCards?.abandon(statusContext.segmentId);
       return true;
     });
   }
@@ -7657,7 +8033,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);
         }
       }
     });
@@ -7700,7 +8076,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);
@@ -7717,14 +8093,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]);
@@ -7750,6 +8150,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;
@@ -7980,9 +8391,102 @@ var EMOTION_RETRY_BASE_DELAY_MS = 250;
 var GROUP_MSG_API = "https://api.dingtalk.com/v1.0/robot/groupMessages/send";
 var DIRECT_MSG_API = "https://api.dingtalk.com/v1.0/robot/oToMessages/batchSend";
 var PROACTIVE_MSG_KEY = "sampleMarkdown";
+var PROACTIVE_FILE_MSG_KEY = "sampleFile";
 var TOKEN_API = "https://oapi.dingtalk.com/gettoken";
 var PROACTIVE_FETCH_TIMEOUT_MS = 15e3;
+var ROBOT_MESSAGE_HOSTS = /* @__PURE__ */ new Set(["api.dingtalk.com", "oapi.dingtalk.com"]);
+var PERMANENT_TOKEN_ERROR_CODES = /* @__PURE__ */ new Set([
+  40001,
+  40013,
+  40089,
+  40096,
+  90002,
+  90003
+]);
 var REPLY_FETCH_TIMEOUT_MS = 15e3;
+function presentInboundError(error) {
+  const parts = [];
+  let status;
+  try {
+    if (error instanceof Error) {
+      if (typeof error.name === "string")
+        parts.push(error.name);
+      if (typeof error.message === "string")
+        parts.push(error.message);
+    } else if (typeof error === "string") {
+      parts.push(error);
+    }
+    if (typeof error === "object" && error !== null) {
+      const record = error;
+      if (typeof record["code"] === "string")
+        parts.push(record["code"]);
+      if (typeof record["status"] === "number")
+        status = record["status"];
+      const body = record["body"];
+      if (typeof body === "string") {
+        parts.push(body);
+      } else if (typeof body === "object" && body !== null) {
+        const bodyRecord = body;
+        for (const key of ["code", "errorKind", "message"]) {
+          if (typeof bodyRecord[key] === "string")
+            parts.push(bodyRecord[key]);
+        }
+      }
+    }
+  } catch {
+    return {
+      status: "Processing failed",
+      nextStep: "Try again. If it keeps failing, contact the bot administrator."
+    };
+  }
+  const diagnostic = parts.join(" ").slice(0, 2e3).toLowerCase();
+  if (status === 401 || status === 403 || /unauthor|forbidden|authentication|credential|invalid.?token/.test(diagnostic)) {
+    return {
+      status: "Bot configuration error",
+      nextStep: "Contact the bot administrator."
+    };
+  }
+  if (status === 408 || status === 504 || /timeout|timed?\s+out|deadline/.test(diagnostic)) {
+    return {
+      status: "Request timed out",
+      nextStep: "Try again. For a large request, split it into smaller parts."
+    };
+  }
+  if (/cancel|abort/.test(diagnostic)) {
+    return {
+      status: "Request was cancelled",
+      nextStep: "Send the request again if you still need it."
+    };
+  }
+  if (status === 429 || /overload|rate.?limit|queue.?full|too many|busy|pending prompts full/.test(diagnostic)) {
+    return {
+      status: "Service is busy",
+      nextStep: "Try again in a moment."
+    };
+  }
+  if (status === 502 || status === 503 || /unavailable|econn|enotfound|etimedout|network|socket|fetch failed|connection|session[_ ](?:not[ _]found|closing)|workspace[_ ]draining|transport closed/.test(diagnostic)) {
+    return {
+      status: "Service is temporarily unavailable",
+      nextStep: "Try again in a moment. If it keeps failing, contact the bot administrator."
+    };
+  }
+  return {
+    status: "Processing failed",
+    nextStep: "Try again. If it keeps failing, contact the bot administrator."
+  };
+}
+__name(presentInboundError, "presentInboundError");
+function formatInboundErrorMessage(error, reference) {
+  const presentation = presentInboundError(error);
+  return [
+    "**Unable to process this message**",
+    "",
+    `**Status:** ${presentation.status}`,
+    `**Next step:** ${presentation.nextStep}`,
+    `**Reference:** \`${reference}\``
+  ].join("\n");
+}
+__name(formatInboundErrorMessage, "formatInboundErrorMessage");
 var GENERATED_MEDIA_EXT = {
   "image/jpeg": "jpg",
   "image/png": "png",
@@ -8002,6 +8506,15 @@ var IMAGE_INSTRUCTIONS = [
   "",
   "Only use a real image file inside the workspace or system temporary directory."
 ].join("\n");
+var FILE_INSTRUCTIONS = [
+  "",
+  "When the user explicitly asks for a completed local file, send it by writing this on its own line:",
+  "`[FILE: /absolute/path/to/file]` (without the backticks)",
+  "",
+  "Use at most five non-empty files inside the workspace or system temporary directory.",
+  "File paths containing ] are not supported.",
+  "Do not claim delivery succeeded; DingTalk shows successful files separately and reports failures in the final text."
+].join("\n");
 function collectNonBotMentionIds(data) {
   if (!Array.isArray(data.atUsers) || typeof data.chatbotUserId !== "string") {
     return [];
@@ -8083,6 +8596,9 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
     } else if (!this.config.instructions.includes("[IMAGE:")) {
       this.config.instructions += IMAGE_INSTRUCTIONS;
     }
+    if (config.blockStreaming !== "on" && !this.config.instructions.includes("[FILE:")) {
+      this.config.instructions += FILE_INSTRUCTIONS;
+    }
     this.interactiveCardConfig = parseDingtalkInteractiveCardConfig(config.interactiveCards);
     if (!config.clientId || !config.clientSecret) {
       throw new Error(`Channel "${name}" requires clientId and clientSecret for DingTalk.`);
@@ -8096,7 +8612,12 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
     if (this.interactiveCardConfig.enabled) {
       this.interactiveCardClient = new DingtalkInteractiveCardClient({
         robotCode: config.clientId,
-        getAccessToken: /* @__PURE__ */ __name(() => this.getProactiveToken(), "getAccessToken")
+        getAccessToken: /* @__PURE__ */ __name(() => this.getProactiveToken(), "getAccessToken"),
+        invalidateAccessToken: /* @__PURE__ */ __name((token) => {
+          if (this.proactiveToken?.token === token) {
+            this.proactiveToken = void 0;
+          }
+        }, "invalidateAccessToken")
       });
       if (this.interactiveCardConfig.statusCard.enabled && config.blockStreaming !== "on") {
         this.statusCardController = new StatusCardController({
@@ -8113,7 +8634,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)}
@@ -8126,7 +8647,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")
           } : {}
         });
       }
@@ -8315,24 +8836,135 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
   static isUnroutableGroupMessage(isGroup, conversationId) {
     return isGroup && !conversationId;
   }
-  projectOutgoingFileText(text, streamed) {
+  resolveSessionWebhook(chatId) {
+    const value = this.webhooks.get(chatId);
+    if (!value)
+      return void 0;
+    try {
+      const url2 = new URL(value);
+      return url2.protocol === "https:" && url2.port === "" && ROBOT_MESSAGE_HOSTS.has(url2.hostname) ? url2.toString() : void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  async uploadOutboundFile(filePath) {
+    const file = readValidatedFile(filePath, this.config.cwd);
+    for (let attempt = 0; attempt < 2; attempt++) {
+      const token = await this.getProactiveToken();
+      try {
+        return { file, mediaId: await uploadDingTalkFile(file, token) };
+      } catch (error) {
+        if (error instanceof DingTalkMediaUploadError && error.authFailure && attempt === 0) {
+          this.proactiveToken = void 0;
+          continue;
+        }
+        throw error;
+      }
+    }
+    throw new Error("DingTalk file upload returned no MediaID");
+  }
+  async deliverFiles(paths, send, preflight) {
+    const notices = [];
+    for (const filePath of paths) {
+      const displayName = safeFileName(filePath);
+      try {
+        preflight?.();
+        const { file, mediaId } = await this.uploadOutboundFile(filePath);
+        await send(file, mediaId);
+      } catch (error) {
+        process.stderr.write(`[DingTalk:${this.name}] outbound file delivery failed (${sanitizeLogText(displayName, 200)}): ${sanitizeLogText(error instanceof Error ? error.message : String(error), 300)}
+`);
+        notices.push(`[File delivery failed: ${displayName}]`);
+      }
+    }
+    return notices;
+  }
+  async sendSessionFile(chatId, file, mediaId) {
+    const webhook = this.resolveSessionWebhook(chatId);
+    if (!webhook)
+      throw new Error("DingTalk session webhook unavailable");
+    let response;
+    try {
+      response = await fetch(webhook, {
+        method: "POST",
+        redirect: "error",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          msgtype: "file",
+          file: {
+            mediaId,
+            fileName: file.fileName,
+            fileType: file.fileType
+          }
+        }),
+        signal: AbortSignal.timeout(REPLY_FETCH_TIMEOUT_MS)
+      });
+    } catch {
+      throw new Error("DingTalk file delivery failed: network request failed");
+    }
+    const body = await response.text().catch(() => "");
+    if (!response.ok) {
+      throw new Error(`DingTalk file delivery failed: HTTP ${response.status}`);
+    }
+    if (!body.trim())
+      return;
+    let data;
+    try {
+      const parsed = JSON.parse(body);
+      if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+        return;
+      data = parsed;
+    } catch {
+      return;
+    }
+    const code = data["errcode"] ?? data["code"];
+    if (code !== void 0 && String(code) !== "0") {
+      throw new Error(`DingTalk file delivery failed: API code ${code}`);
+    }
+  }
+  appendFileNotices(text, notices) {
+    if (notices.length === 0)
+      return text;
+    const prefix = text.trimEnd();
+    return `${prefix}${prefix ? "\n" : ""}${notices.join("\n")}`;
+  }
+  async prepareReplyOutput(chatId, text, streamed) {
+    return this.prepareFileOutput(text, (file, mediaId) => this.sendSessionFile(chatId, file, mediaId), streamed, () => {
+      if (!this.resolveSessionWebhook(chatId)) {
+        throw new Error("DingTalk session webhook unavailable");
+      }
+    });
+  }
+  async prepareFileOutput(text, send, streamed, preflight) {
     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})
+    if (projection.markerCount > 0 || streamedMarkers > 0) {
+      process.stderr.write(`[DingTalk:${this.name}] file markers projected (final=${projection.markerCount}, streamed=${streamedMarkers})
 `);
-    return withFileUnavailableNotice(projection.text);
+    }
+    if (this.config.blockStreaming === "on" && (projection.markerCount > 0 || streamedMarkers > 0)) {
+      return this.prepareOutgoingText(withFileUnavailableNotice(projection.text));
+    }
+    const notices = [];
+    if (projection.invalidMarkers > 0) {
+      notices.push("[File delivery failed: invalid marker]");
+    }
+    if (projection.excessMarkers > 0) {
+      notices.push("[File delivery failed: response file limit exceeded]");
+    }
+    if (streamedMarkers > projection.markerCount) {
+      notices.push(FILE_UNAVAILABLE_NOTICE);
+    }
+    notices.push(...await this.deliverFiles(projection.paths, send, preflight));
+    return this.prepareOutgoingText(this.appendFileNotices(projection.text, notices));
   }
-  async prepareOutgoingText(text, streamed) {
-    const fileSafeText = this.projectOutgoingFileText(text, streamed);
-    const markers = findImageMarkers(fileSafeText);
+  async prepareOutgoingText(text) {
+    const markers = findImageMarkers(text);
     if (markers.length === 0)
-      return fileSafeText;
+      return text;
     const replacements = [];
     for (const marker of markers) {
-      const fileName = basename2(marker.path).replace(/[\r\n[\]]+/g, "_").slice(0, 100) || "image";
+      const fileName = basename3(marker.path).replace(/[\r\n[\]]+/g, "_").slice(0, 100) || "image";
       try {
         const image = readValidatedImage(marker.path, {
           workspaceDir: this.config.cwd
@@ -8361,20 +8993,29 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
         replacements.push(`[Image delivery failed: ${fileName}]`);
       }
     }
-    return replaceImageMarkers(fileSafeText, markers, replacements);
+    return replaceImageMarkers(text, markers, replacements);
   }
-  async sendReply(chatId, text, atUserId) {
+  async sendReply(chatId, text, atUserId, sourceLabel, prepared = false) {
     const webhook = this.webhooks.get(chatId);
     if (!webhook) {
       process.stderr.write(`[DingTalk:${this.name}] No webhook for chatId ${chatId}, cannot send.
 `);
       return;
     }
-    const outgoingText = await this.prepareOutgoingText(text);
+    const outgoingText = prepared ? text : await this.prepareReplyOutput(chatId, text);
+    if (!outgoingText.trim())
+      return;
     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];
@@ -8418,6 +9059,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;
   }
@@ -8436,11 +9080,20 @@ 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 outgoingText = await this.prepareFileOutput(text, (file, mediaId) => this.sendProactiveFile(target, file, mediaId));
+    if (!outgoingText.trim())
+      return;
+    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}`);
@@ -8466,7 +9119,7 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
       const errmsg = sanitizeLogText(String(data.errmsg ?? ""), 200);
       process.stderr.write(`[DingTalk:${this.name}] access token request failed: gettoken errcode=${data.errcode} ${errmsg}
 `);
-      throw new Error(`DingTalk access token request failed: gettoken errcode=${data.errcode}${errmsg ? ` ${errmsg}` : ""}`);
+      throw new DingtalkCardRequestError(`DingTalk access token request failed: gettoken errcode=${data.errcode}${errmsg ? ` ${errmsg}` : ""}`, !PERMANENT_TOKEN_ERROR_CODES.has(Number(data.errcode)));
     }
     this.proactiveToken = {
       token: data.access_token,
@@ -8492,6 +9145,12 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
     }, "\u5361\u7247\u64CD\u4F5C", "\u4F60\u65E0\u6743\u64CD\u4F5C\u8FD9\u5F20\u5361\u7247\uFF0C\u4EC5\u4EFB\u52A1\u53D1\u8D77\u4EBA\u53EF\u4EE5\u63D0\u4EA4\u6216\u505C\u6B62\u3002", "card interaction feedback");
   }
   async sendProactiveChunk(target, title, text, chunkLabel) {
+    return this.sendProactivePayload(target, PROACTIVE_MSG_KEY, { title, text }, chunkLabel);
+  }
+  async sendProactiveFile(target, file, mediaId) {
+    return this.sendProactivePayload(target, PROACTIVE_FILE_MSG_KEY, { mediaId, fileName: file.fileName, fileType: file.fileType }, `file ${file.fileName}`);
+  }
+  async sendProactivePayload(target, msgKey, msgParam, chunkLabel) {
     const targetKind = target.isGroup === true ? "group" : "dm";
     for (let attempt = 0; ; attempt++) {
       const token = await this.getProactiveToken();
@@ -8507,8 +9166,8 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
           body: JSON.stringify({
             robotCode: this.config.clientId,
             ...targetBody,
-            msgKey: PROACTIVE_MSG_KEY,
-            msgParam: JSON.stringify({ title, text })
+            msgKey,
+            msgParam: JSON.stringify(msgParam)
           }),
           signal: AbortSignal.timeout(PROACTIVE_FETCH_TIMEOUT_MS)
         });
@@ -8529,6 +9188,27 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
 `);
         throw new Error(`DingTalk proactive send failed: HTTP ${resp.status}${detail ? ` ${detail}` : ""}`);
       }
+      if (target.isGroup === true) {
+        if (msgKey !== PROACTIVE_FILE_MSG_KEY) {
+          await resp.body?.cancel();
+          return;
+        }
+        let data;
+        try {
+          const parsed = await resp.json();
+          data = parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+        } catch {
+          throw new Error("DingTalk file delivery failed: invalid JSON response");
+        }
+        const code = data["errcode"] ?? data["code"];
+        if (code !== void 0 && String(code) !== "0") {
+          throw new Error(`DingTalk file delivery failed: API code ${code}`);
+        }
+        if (typeof data["processQueryKey"] !== "string" || !data["processQueryKey"].trim()) {
+          throw new Error("DingTalk file delivery failed: missing processQueryKey");
+        }
+        return;
+      }
       if (target.isGroup === false) {
         let data;
         try {
@@ -8548,6 +9228,9 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
 `);
           throw new Error("DingTalk proactive send failed: direct recipient rate limited");
         }
+        if (msgKey === PROACTIVE_FILE_MSG_KEY && !data.processQueryKey?.trim()) {
+          throw new Error("DingTalk file delivery failed: missing processQueryKey");
+        }
         return;
       }
       await resp.body?.cancel();
@@ -8612,6 +9295,7 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
     if (this.dedupTimer) {
       clearInterval(this.dedupTimer);
     }
+    this.statusCardController?.dispose();
     this.activeReactionKeys.clear();
     this.sessionReactionKeys.clear();
     if (this.connectionManager) {
@@ -8733,7 +9417,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;
@@ -8873,7 +9558,7 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
     const tail = state.projector.complete();
     if (!tail.trim())
       return;
-    void this.sendReply(chatId, tail).catch((err) => {
+    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)}
 `);
     });
@@ -8883,13 +9568,13 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
    * 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) {
+  async deliverBackgroundReply(chatId, text, sessionId, sourceLabel) {
     if (this.config.blockStreaming !== "on") {
-      return super.deliverBackgroundReply(chatId, text, sessionId);
+      return super.deliverBackgroundReply(chatId, text, sessionId, sourceLabel);
     }
-    await this.sendReply(chatId, text);
+    await this.sendReply(chatId, text, void 0, sourceLabel);
   }
-  async sendResponseMessage(chatId, text, sessionId) {
+  async sendResponseMessage(chatId, text, sessionId, sourceLabel, prepared = false) {
     let outgoingText = text;
     let consumesMention = true;
     if (this.config.blockStreaming === "on") {
@@ -8902,7 +9587,7 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
     const atUserId = consumesMention && this.atSender ? this.sessionMentionTargets.get(sessionId) : void 0;
     if (atUserId)
       this.sessionMentionTargets.delete(sessionId);
-    await this.sendReply(chatId, outgoingText, atUserId);
+    await this.sendReply(chatId, outgoingText, atUserId, sourceLabel ?? this.getResponseSourceLabel(sessionId), prepared);
   }
   projectBlockStreamChunk(text, sessionId) {
     let state = this.blockFileProjectors.get(sessionId);
@@ -8925,21 +9610,21 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
     }
     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);
+    const outgoingText = await this.prepareReplyOutput(chatId, text, streamed);
     if (segment && this.interactionPresenter) {
       if (await this.interactionPresenter.closeOutput(segment.segmentId, outgoingText, "completed", segment)) {
         return;
       }
     }
-    await this.sendResponseMessage(chatId, outgoingText, sessionId);
+    await this.sendResponseMessage(chatId, outgoingText, sessionId, segment?.sourceLabel, true);
   }
   onOutputSegmentEnd(_chatId, _sessionId, segment, reason) {
     if (reason === "completed" || reason === "failed" || reason === "cancelled") {
@@ -9205,9 +9890,9 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
       let filePath;
       let safeName;
       try {
-        dir = join(tmpdir2(), "channel-files", randomUUID5());
+        dir = join(tmpdir3(), "channel-files", randomUUID5());
         mkdirSync(dir, { recursive: true });
-        safeName = basename2(typeof fileName === "string" ? fileName : "") || `dingtalk_${mediaType}_${Date.now()}.${GENERATED_MEDIA_EXT[media.mimeType] ?? "bin"}`;
+        safeName = basename3(typeof fileName === "string" ? fileName : "") || `dingtalk_${mediaType}_${Date.now()}.${GENERATED_MEDIA_EXT[media.mimeType] ?? "bin"}`;
         filePath = join(dir, safeName);
         writeFileSync(filePath, media.buffer);
       } catch (error) {
@@ -9311,9 +9996,18 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
         }
       }) : this.handleInbound(envelope);
       processMessage.catch((err) => {
-        process.stderr.write(`[DingTalk:${this.name}] Error handling message: ${err}
+        const reference = randomUUID5().slice(0, 8);
+        let errorSummary = "Unknown error";
+        try {
+          errorSummary = err instanceof Error ? `${err.name}: ${err.message}` : String(err);
+        } catch {
+        }
+        process.stderr.write(`[DingTalk:${this.name}] Error handling message ref=${reference}: ${sanitizeLogText(errorSummary, 300)}
 `);
-        this.sendMessage(chatId, "Sorry, something went wrong processing your message.").catch(() => {
+        const fallbackMessage = formatInboundErrorMessage(err, reference);
+        const sourceLabel = this.getInboundErrorSourceLabel(envelope);
+        const delivery = sourceLabel ? this.sendThreadMessage(chatId, envelope.threadId, fallbackMessage, sourceLabel) : this.sendMessage(chatId, fallbackMessage);
+        delivery.catch(() => {
         });
       });
     } catch (err) {