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

package/chunks/{dist-5423MG3D.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-IXEZHTDR.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
@@ -6177,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 {
@@ -6277,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();
@@ -6590,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,
@@ -6638,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);
       }
     }
   }
@@ -6663,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);
   }
 };
 
@@ -6804,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) {
@@ -6823,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)) {
@@ -6834,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);
@@ -6844,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
@@ -6868,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 = {
@@ -6897,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);
@@ -6925,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)
@@ -6933,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 };
@@ -6961,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(() => {
@@ -7007,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;
@@ -7057,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));
@@ -7119,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);
@@ -7142,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;
@@ -7628,6 +7968,7 @@ var DingtalkInteractionPresenter = class {
         if (!fallbackText2 || !this.options.sendFallback)
           return false;
         await this.sendFallback(run, presentation.context.target.chatId, fallbackText2, presentation.context.sessionId);
+        statusCards?.abandon(statusContext.segmentId);
         return true;
       }
       if (reason === "input_requested") {
@@ -7639,6 +7980,7 @@ var DingtalkInteractionPresenter = class {
         if (!fallbackText2 || !this.options.sendFallback)
           return false;
         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));
@@ -7649,6 +7991,7 @@ var DingtalkInteractionPresenter = class {
       if (!fallbackText || !this.options.sendFallback)
         return false;
       await this.sendFallback(run, presentation.context.target.chatId, fallbackText, presentation.context.sessionId);
+      statusCards?.abandon(statusContext.segmentId);
       return true;
     });
   }
@@ -8048,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",
@@ -8070,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 [];
@@ -8151,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.`);
@@ -8164,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({
@@ -8383,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
@@ -8429,16 +8993,18 @@ 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, sourceLabel) {
+  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}
 
 ` : "";
@@ -8517,7 +9083,9 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
   async pushProactive(target, text, sourceLabel) {
     if (!text.trim())
       return;
-    const outgoingText = await this.prepareOutgoingText(text);
+    const outgoingText = await this.prepareFileOutput(text, (file, mediaId) => this.sendProactiveFile(target, file, mediaId));
+    if (!outgoingText.trim())
+      return;
     const sourcePrefix = sourceLabel ? `${escapeDingTalkMarkdown(sourceLabel)}
 
 ` : "";
@@ -8551,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,
@@ -8577,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();
@@ -8592,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)
         });
@@ -8614,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 {
@@ -8633,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();
@@ -8697,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) {
@@ -8975,7 +9574,7 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
     }
     await this.sendReply(chatId, text, void 0, sourceLabel);
   }
-  async sendResponseMessage(chatId, text, sessionId, sourceLabel) {
+  async sendResponseMessage(chatId, text, sessionId, sourceLabel, prepared = false) {
     let outgoingText = text;
     let consumesMention = true;
     if (this.config.blockStreaming === "on") {
@@ -8988,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, sourceLabel ?? this.getResponseSourceLabel(sessionId));
+    await this.sendReply(chatId, outgoingText, atUserId, sourceLabel ?? this.getResponseSourceLabel(sessionId), prepared);
   }
   projectBlockStreamChunk(text, sessionId) {
     let state = this.blockFileProjectors.get(sessionId);
@@ -9019,13 +9618,13 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
     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, segment?.sourceLabel);
+    await this.sendResponseMessage(chatId, outgoingText, sessionId, segment?.sourceLabel, true);
   }
   onOutputSegmentEnd(_chatId, _sessionId, segment, reason) {
     if (reason === "completed" || reason === "failed" || reason === "cancelled") {
@@ -9291,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) {
@@ -9397,10 +9996,17 @@ 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)}
 `);
+        const fallbackMessage = formatInboundErrorMessage(err, reference);
         const sourceLabel = this.getInboundErrorSourceLabel(envelope);
-        const delivery = sourceLabel ? this.sendThreadMessage(chatId, envelope.threadId, "Sorry, something went wrong processing your message.", sourceLabel) : this.sendMessage(chatId, "Sorry, something went wrong processing your message.");
+        const delivery = sourceLabel ? this.sendThreadMessage(chatId, envelope.threadId, fallbackMessage, sourceLabel) : this.sendMessage(chatId, fallbackMessage);
         delivery.catch(() => {
         });
       });