@qwen-code/qwen-code 0.23.5-dev.codemode-responses.20260915.f024b37689 → 0.23.5-preview.0

package/chunks/{dist-SE4J6Z4O.js → dist-BNW423XT.js}

@@ -8,13 +8,16 @@ import {
 import "./chunk-K6KS3LTN.js";
 import "./chunk-OSHQMOBS.js";
 import {
+  BackgroundOutputCoordinator,
   ChannelBase,
+  ChannelOutputTurn,
   isTerminalTaskLifecycleType,
+  parseChannelOutputMode,
   sanitizeLogText,
   sanitizePromptText,
   sanitizeSenderName,
   truncateUtf16Units
-} from "./chunk-EPVEPTI3.js";
+} from "./chunk-PZRXWQUA.js";
 import "./chunk-IJOS26LH.js";
 import "./chunk-CQ35AJ4Z.js";
 import "./chunk-DMTGGOSA.js";
@@ -6690,10 +6693,10 @@ 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) {
+function isRetryableDingtalkStatus(status) {
   return status === 408 || status === 425 || status === 429 || status >= 500 && status <= 599;
 }
-__name(isRetryableStatus, "isRetryableStatus");
+__name(isRetryableDingtalkStatus, "isRetryableDingtalkStatus");
 var DingtalkCardRequestError = class extends Error {
   static {
     __name(this, "DingtalkCardRequestError");
@@ -6800,7 +6803,7 @@ var DingtalkInteractiveCardClient = class {
       }
       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));
+        throw new DingtalkCardRequestError(`DingTalk Card OpenAPI ${method} ${path} failed${templateId ? ` for ${templateId}` : ""}: HTTP ${response.status}${detail ? ` ${detail}` : ""}`, isRetryableDingtalkStatus(response.status));
       }
       return response.json().catch(() => void 0);
     }
@@ -6976,6 +6979,17 @@ function isChinesePresentationLanguage(language) {
   return normalized === "zh" || normalized === "zh-cn";
 }
 __name(isChinesePresentationLanguage, "isChinesePresentationLanguage");
+function partialOutputLabel(language) {
+  return isChinesePresentationLanguage(language) ? "\uFF08\u90E8\u5206\uFF09" : "(partial)";
+}
+__name(partialOutputLabel, "partialOutputLabel");
+function markPartialOutput(text, language) {
+  const label = partialOutputLabel(language);
+  return !text.trim() || text.startsWith(label) ? text : `${label}
+
+${text}`;
+}
+__name(markPartialOutput, "markPartialOutput");
 function presentationPhaseLabel(phase, language) {
   return (isChinesePresentationLanguage(language) ? DINGTALK_ZH_PRESENTATION_PHASE_LABELS : DINGTALK_PRESENTATION_PHASE_LABELS)[phase];
 }
@@ -7074,6 +7088,38 @@ var StatusCardController = class {
   constructor(options) {
     this.options = options;
   }
+  async deliverCompletedResult(target, text, sourceLabel, result = { status: "completed" }) {
+    const content = sourceLabel ? `${escapeDingTalkMarkdown(sourceLabel)}
+
+${text}` : text;
+    if (this.disposed || !text.trim() || content.length > CONTENT_LIMIT) {
+      return false;
+    }
+    const state = result.status === "failed" ? "Failed" : result.status === "stopped" ? "Stopped" : result.status === "cancelled" ? "Cancelled" : result.partial || result.status !== "completed" ? "Partial" : "Completed";
+    try {
+      await this.options.client.createAndDeliver({
+        templateId: STATUS_CARD_TEMPLATE_ID,
+        outTrackId: `qwen-result-${randomUUID2()}`,
+        target,
+        cardParamMap: this.terminalCardParams(content, [this.statusStateLabel(state), this.options.model?.trim()].filter(Boolean).join(" \xB7 "))
+      });
+      return true;
+    } catch (error) {
+      this.options.onError?.("completed result card", error);
+      return false;
+    }
+  }
+  terminalCardParams(content, statusLine) {
+    return {
+      blockList: JSON.stringify([{ type: 0, markdown: content }]),
+      content,
+      copy_content: content,
+      flowStatus: 3,
+      statusLine,
+      hasAction: "false",
+      stop_action: "false"
+    };
+  }
   ensure(segment, target) {
     if (this.disposed)
       return;
@@ -7226,8 +7272,8 @@ var StatusCardController = class {
     });
     return record;
   }
-  complete(segmentId, text, retainedContent) {
-    return this.finalize(segmentId, boundContent(text), "Completed", false, retainedContent);
+  complete(segmentId, text, retainedContent, partial = false) {
+    return this.finalize(segmentId, boundContent(text), partial ? "Partial" : "Completed", false, retainedContent);
   }
   updateRunPhase(runId, phase) {
     if (this.disposed)
@@ -7465,20 +7511,7 @@ var StatusCardController = class {
     try {
       await this.options.client.updateInstance({
         outTrackId: record.outTrackId,
-        cardParamMap: {
-          blockList: JSON.stringify([
-            {
-              type: 0,
-              markdown: intent.content
-            }
-          ]),
-          content: intent.content,
-          copy_content: intent.content,
-          flowStatus: 3,
-          statusLine: intent.statusLine,
-          hasAction: "false",
-          stop_action: "false"
-        }
+        cardParamMap: this.terminalCardParams(intent.content, intent.statusLine)
       });
       record.content = "";
       this.removeRecord(record);
@@ -7592,7 +7625,8 @@ var StatusCardController = class {
       Completed: "\u5DF2\u5B8C\u6210",
       Failed: "\u5DF2\u5931\u8D25",
       Stopped: "\u5DF2\u7EC8\u6B62",
-      Cancelled: "\u5DF2\u53D6\u6D88"
+      Cancelled: "\u5DF2\u53D6\u6D88",
+      Partial: "\u90E8\u5206\u7ED3\u679C"
     }[state] ?? state;
   }
   async updateRunningStatus(record) {
@@ -8299,7 +8333,7 @@ var DingtalkInteractionPresenter = class {
   constructor(options) {
     this.options = options;
   }
-  registerRun(runId, ownerId, target, sessionId = "", sender, sourceLabel) {
+  registerRun(runId, ownerId, target, sessionId = "", sender, sourceLabel, sendFallback) {
     this.runs.set(runId, {
       runId,
       ownerId,
@@ -8319,8 +8353,10 @@ var DingtalkInteractionPresenter = class {
         sourceLabel
       },
       projectionChain: Promise.resolve(),
+      output: new ChannelOutputTurn(this.options.outputMode),
       ...target.isGroup && sender ? formatSenderPrefixes(sender) : {},
       ...sourceLabel ? { sourceLabel } : {},
+      ...sendFallback ? { sendFallback } : {},
       terminal: false
     });
   }
@@ -8352,14 +8388,20 @@ var DingtalkInteractionPresenter = class {
     const presentation = existing ?? {
       run,
       context: segment,
-      content: ""
+      content: "",
+      preview: "",
+      visible: false
     };
-    presentation.content = this.boundContent(presentation.content + chunk);
+    presentation.content += chunk;
+    presentation.preview = this.boundContent(presentation.preview + chunk);
+    presentation.visible ||= chunk.trim().length > 0;
     this.segments.set(segment.segmentId, presentation);
     run.activeSegmentId = segment.segmentId;
-    const statusContext = this.ensureStatusContext(run, segment);
+    if (!run.output.shouldPreview(presentation.visible ? "visible" : ""))
+      return;
     void this.enqueue(run, () => {
-      this.options.statusCards?.replace(statusContext, this.cardTarget(statusContext.target), this.withSourcePrefix(run, presentation.content));
+      const statusContext = this.ensureStatusContext(run, segment);
+      this.options.statusCards?.replace(statusContext, this.cardTarget(statusContext.target), this.withSourcePrefix(run, presentation.preview));
     });
   }
   closeOutput(segmentId, text, reason, segment) {
@@ -8379,52 +8421,46 @@ var DingtalkInteractionPresenter = class {
       run.activeSegmentId = void 0;
     }
     return this.enqueue(run, async () => {
+      const decision = run.output.close(text || presentation.content, reason);
+      if (decision.kind === "skip")
+        return true;
       const statusCards = this.options.statusCards;
       const statusContext = this.ensureStatusContext(run, presentation.context);
-      if (reason === "failed") {
+      if (decision.kind === "failed") {
         statusCards?.ensure(statusContext, this.cardTarget(statusContext.target));
         statusCards?.fail(statusContext.segmentId, this.withSenderPrefix(run, "\u672C\u6B21\u5904\u7406\u5931\u8D25\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5\u3002"));
         await this.redeliverCardDeliveredContent(run);
         return statusCards !== void 0;
       }
-      if (reason === "cancelled") {
+      if (decision.kind === "cancelled") {
         return statusCards !== void 0;
       }
-      if (reason === "response_boundary") {
+      if (decision.kind === "preview") {
         const deliveredViaCard = statusCards !== void 0 && await statusCards.isCardLive(statusContext.segmentId) && await statusCards.flushPending(statusContext.segmentId);
         if (deliveredViaCard) {
           run.cardDelivered = {
-            text: stripPartialImageMarker(text || presentation.content),
+            text: stripPartialImageMarker(decision.text),
             chatId: presentation.context.target.chatId,
             sessionId: presentation.context.sessionId
           };
-          return true;
         }
-        const fallbackText2 = stripPartialImageMarker(text || presentation.content);
-        if (!fallbackText2 || !this.options.sendFallback)
-          return false;
-        await this.sendFallback(run, presentation.context.target.chatId, fallbackText2, presentation.context.sessionId);
-        statusCards?.abandon(statusContext.segmentId);
+        run.lastOutputContext = presentation.context;
         return true;
       }
-      if (reason === "input_requested") {
-        const completed2 = statusCards !== void 0 && await statusCards.complete(statusContext.segmentId, this.withSenderPrefix(run, text || presentation.content));
-        run.statusContext = void 0;
-        if (completed2)
-          return true;
-        const fallbackText2 = stripPartialImageMarker(text || presentation.content);
-        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 (!decision.rotate) {
+        statusCards?.ensure(statusContext, this.cardTarget(statusContext.target));
       }
-      statusCards?.ensure(statusContext, this.cardTarget(statusContext.target));
-      const completed = statusCards !== void 0 && await statusCards.complete(statusContext.segmentId, this.withSenderPrefix(run, text || presentation.content));
+      let output = this.options.prepareOutput ? await this.options.prepareOutput(presentation.context.target.chatId, decision.text) : decision.text;
+      const partial = segment?.partial ?? presentation.context.partial;
+      if (partial)
+        output = markPartialOutput(output, this.options.language);
+      const completed = statusCards !== void 0 && await statusCards.complete(statusContext.segmentId, this.withSenderPrefix(run, output), void 0, partial);
+      if (decision.rotate)
+        run.statusContext = void 0;
       if (completed)
         return true;
-      const fallbackText = stripPartialImageMarker(text || presentation.content);
-      if (!fallbackText || !this.options.sendFallback)
+      const fallbackText = stripPartialImageMarker(output);
+      if (!fallbackText || !(run.sendFallback ?? this.options.sendFallback))
         return false;
       await this.sendFallback(run, presentation.context.target.chatId, fallbackText, presentation.context.sessionId);
       statusCards?.abandon(statusContext.segmentId);
@@ -8480,6 +8516,7 @@ var DingtalkInteractionPresenter = class {
     }
     const copy = this.terminalCopy();
     const finalization = this.enqueue(run, async () => {
+      const finalOutput = run.output.finish(terminal);
       if (terminal === "failed") {
         const statusContext = this.ensureStatusContext(run);
         this.options.statusCards?.ensure(statusContext, this.cardTarget(statusContext.target));
@@ -8495,7 +8532,12 @@ var DingtalkInteractionPresenter = class {
       } else {
         const statusContext = run.statusContext;
         if (statusContext) {
-          await this.options.statusCards?.complete(statusContext.segmentId, "", (retained) => retained ? this.withSenderPrefix(run, this.withoutRenderedSourcePrefix(run, retained)) : retained);
+          const context = run.lastOutputContext ?? run.baseContext;
+          const output = finalOutput && this.options.prepareOutput ? await this.options.prepareOutput(context.target.chatId, finalOutput) : finalOutput;
+          const completed = await this.options.statusCards?.complete(statusContext.segmentId, output ? this.withSenderPrefix(run, output) : "", (retained) => retained ? this.withSenderPrefix(run, this.withoutRenderedSourcePrefix(run, retained)) : retained);
+          if (!completed && output) {
+            await this.sendFallback(run, context.target.chatId, stripPartialImageMarker(output), context.sessionId);
+          }
         }
       }
     });
@@ -8535,7 +8577,7 @@ var DingtalkInteractionPresenter = class {
    */
   async redeliverCardDeliveredContent(run) {
     const delivered = run.cardDelivered;
-    if (!delivered || !this.options.sendFallback)
+    if (!delivered || !(run.sendFallback ?? this.options.sendFallback))
       return;
     run.cardDelivered = void 0;
     await this.sendFallback(run, delivered.chatId, delivered.text, delivered.sessionId);
@@ -8580,13 +8622,14 @@ var DingtalkInteractionPresenter = class {
 ${this.boundContent(content, Math.max(0, CONTENT_LIMIT - sourceLabel.length - 2))}`;
   }
   async sendFallback(run, chatId, text, sessionId) {
-    if (!this.options.sendFallback)
+    const sendFallback = run.sendFallback ?? this.options.sendFallback;
+    if (!sendFallback)
       return;
     if (run.sourceLabel) {
-      await this.options.sendFallback(chatId, text, sessionId, run.sourceLabel);
+      await sendFallback(chatId, text, sessionId, run.sourceLabel);
       return;
     }
-    await this.options.sendFallback(chatId, text, sessionId);
+    await sendFallback(chatId, text, sessionId);
   }
   withoutExistingSenderPrefix(run, content) {
     const prefixes = /* @__PURE__ */ new Set([run.senderPrefix, run.senderRawPrefix]);
@@ -9044,6 +9087,34 @@ async function withConnectLoggingSuppressed(connect) {
   }
 }
 __name(withConnectLoggingSuppressed, "withConnectLoggingSuppressed");
+var ProactiveTextDeliveryError = class extends Error {
+  static {
+    __name(this, "ProactiveTextDeliveryError");
+  }
+  plan;
+  retryable;
+  constructor(plan, cause) {
+    super(cause instanceof Error ? cause.message : String(cause), { cause });
+    this.plan = plan;
+    if (cause instanceof DingtalkCardRequestError) {
+      this.retryable = cause.retryable;
+    }
+  }
+};
+var ReplyTextDeliveryError = class extends Error {
+  static {
+    __name(this, "ReplyTextDeliveryError");
+  }
+  plan;
+  retryable;
+  constructor(plan, cause) {
+    super(cause instanceof Error ? cause.message : String(cause), { cause });
+    this.plan = plan;
+    if (cause instanceof DingtalkCardRequestError) {
+      this.retryable = cause.retryable;
+    }
+  }
+};
 var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
   static {
     __name(this, "DingtalkChannel");
@@ -9064,7 +9135,7 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
   reactionStates = /* @__PURE__ */ new Map();
   /** sessionId → reaction keys, so a dead session's reactions can be recalled. */
   sessionReactionKeys = /* @__PURE__ */ new Map();
-  /** Settles when the reaction cleanup queued by disconnect() has run. */
+  /** Settles after background output and reaction cleanup finish on disconnect. */
   disconnectDrain;
   /**
    * Real inbound message ids (insertion-ordered, size-capped). Unlike the
@@ -9078,6 +9149,7 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
    */
   proactiveToken;
   interactiveCardConfig;
+  outputMode;
   interactiveCardClient;
   statusCardController;
   questionCardController;
@@ -9090,6 +9162,7 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
   // boundary, input requested) mints a fresh segment UUID but the projection
   // state must survive it, or a marker split across the reset leaks.
   fileProjectors = /* @__PURE__ */ new Map();
+  backgroundOutputCoordinator;
   constructor(name, config, bridge, options) {
     super(name, config, bridge, options);
     this.atSender = config["atSender"] === true;
@@ -9108,6 +9181,16 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
       this.config.instructions += FILE_INSTRUCTIONS;
     }
     this.interactiveCardConfig = parseDingtalkInteractiveCardConfig(config.interactiveCards);
+    this.outputMode = parseChannelOutputMode(name, config.outputMode, true);
+    this.backgroundOutputCoordinator = new BackgroundOutputCoordinator({
+      outputMode: this.outputMode,
+      getTarget: /* @__PURE__ */ __name((sessionId) => this.router.getTarget(sessionId), "getTarget"),
+      getSourceLabel: /* @__PURE__ */ __name((sessionId) => this.getBackgroundResponseSourceLabel(sessionId), "getSourceLabel"),
+      resolveDelivery: /* @__PURE__ */ __name((sessionId) => this.resolveBackgroundResponseDelivery(sessionId), "resolveDelivery"),
+      createDelivery: /* @__PURE__ */ __name((sessionId, target) => this.createBackgroundOutputDelivery(sessionId, target), "createDelivery"),
+      isRetryableError: /* @__PURE__ */ __name((error) => !((error instanceof ProactiveTextDeliveryError || error instanceof ReplyTextDeliveryError || error instanceof DingtalkCardRequestError) && error.retryable === false), "isRetryableError"),
+      log: /* @__PURE__ */ __name((message) => process.stderr.write(`[DingTalk:${this.name}] ${message}`), "log")
+    });
     if (!config.clientId || !config.clientSecret) {
       throw new Error(`Channel "${name}" requires clientId and clientSecret for DingTalk.`);
     }
@@ -9163,16 +9246,16 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
           }, "onError")
         });
       }
-      if (this.statusCardController || this.questionCardController || this.permissionCardController) {
-        this.interactionPresenter = new DingtalkInteractionPresenter({
-          statusCards: this.statusCardController,
-          questionCards: this.questionCardController,
-          permissionCards: this.permissionCardController,
-          ...options?.displayLanguage ? { language: options.displayLanguage } : {},
-          sendFallback: /* @__PURE__ */ __name((chatId, text, sessionId, sourceLabel) => this.sendFallbackReply(chatId, text, sessionId, sourceLabel), "sendFallback")
-        });
-      }
     }
+    this.interactionPresenter = new DingtalkInteractionPresenter({
+      outputMode: this.outputMode,
+      prepareOutput: /* @__PURE__ */ __name((chatId, text) => this.prepareReplyOutput(chatId, text), "prepareOutput"),
+      statusCards: this.statusCardController,
+      questionCards: this.questionCardController,
+      permissionCards: this.permissionCardController,
+      ...options?.displayLanguage ? { language: options.displayLanguage } : {},
+      sendFallback: /* @__PURE__ */ __name((chatId, text, sessionId, sourceLabel) => this.sendFallbackReply(chatId, text, sessionId, sourceLabel), "sendFallback")
+    });
     if (useConnectionManager) {
       this.connectionManager = new DingtalkConnectionManager({
         initialClient: this.client,
@@ -9519,18 +9602,25 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
     }
     return replaceImageMarkers(text, markers, replacements);
   }
-  async sendReply(chatId, text, atUserId, sourceLabel, prepared = false) {
+  async sendReply(chatId, text, atUserId, sourceLabel, prepared = false, failOnHttpError = false) {
     const webhook = this.webhooks.get(chatId);
     if (!webhook) {
       process.stderr.write(`[DingTalk:${this.name}] No webhook for chatId ${chatId}, cannot send.
 `);
+      if (failOnHttpError) {
+        throw new Error("DingTalk session webhook unavailable");
+      }
       return;
     }
     const outgoingText = prepared ? text : await this.prepareReplyOutput(chatId, text);
     if (!outgoingText.trim())
       return;
     const plan = this.createReplyTextDelivery(outgoingText, atUserId, sourceLabel);
-    await this.deliverReplyText(chatId, plan);
+    try {
+      await this.deliverReplyText(chatId, plan, failOnHttpError);
+    } catch (error) {
+      throw new ReplyTextDeliveryError(plan, error);
+    }
   }
   createReplyTextDelivery(outgoingText, atUserId, sourceLabel) {
     const mentionPrefix = atUserId ? `@${atUserId}
@@ -9551,9 +9641,12 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
       ...atUserId ? { atUserId } : {}
     };
   }
-  async deliverReplyText(chatId, plan) {
+  async deliverReplyText(chatId, plan, failOnHttpError = false) {
     const webhook = this.webhooks.get(chatId);
     if (!webhook) {
+      if (failOnHttpError) {
+        throw new Error("DingTalk session webhook unavailable");
+      }
       return;
     }
     while (plan.nextChunk < plan.chunks.length) {
@@ -9593,6 +9686,19 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
         const detail = await resp.text().catch(() => "");
         process.stderr.write(`[DingTalk:${this.name}] sendMessage failed: HTTP ${resp.status} ${detail}
 `);
+        if (failOnHttpError) {
+          throw new DingtalkCardRequestError(`DingTalk reply send failed: HTTP ${resp.status} ${detail}`, isRetryableDingtalkStatus(resp.status));
+        }
+      } else if (failOnHttpError) {
+        const payload = await resp.clone().json().catch(() => void 0);
+        const response = payload && typeof payload === "object" ? payload : void 0;
+        const value = response?.["errcode"] ?? response?.["code"];
+        if (value !== void 0 && String(value) !== "0") {
+          const detail = sanitizeLogText(String(response?.["errmsg"] ?? response?.["message"] ?? value), 300);
+          process.stderr.write(`[DingTalk:${this.name}] sendMessage failed: ${detail}
+`);
+          throw new Error(`DingTalk reply send failed: ${detail}`);
+        }
       }
       plan.nextChunk++;
     }
@@ -9627,7 +9733,11 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
     const plan = await this.createProactiveTextDelivery(target, text, sourceLabel);
     if (!plan)
       return;
-    await this.deliverProactiveText(target, plan);
+    try {
+      await this.deliverProactiveText(target, plan);
+    } catch (error) {
+      throw new ProactiveTextDeliveryError(plan, error);
+    }
   }
   async createProactiveTextDelivery(target, text, sourceLabel) {
     const outgoingText = await this.prepareFileOutput(text, (file, mediaId) => this.sendProactiveFile(target, file, mediaId));
@@ -9746,7 +9856,7 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
         const detail = sanitizeLogText(await resp.text().catch(() => ""), 300);
         process.stderr.write(`[DingTalk:${this.name}] proactive send failed (${targetKind}, ${chunkLabel}): HTTP ${resp.status} ${detail}
 `);
-        throw new Error(`DingTalk proactive send failed: HTTP ${resp.status}${detail ? ` ${detail}` : ""}`);
+        throw new DingtalkCardRequestError(`DingTalk proactive send failed: HTTP ${resp.status}${detail ? ` ${detail}` : ""}`, isRetryableDingtalkStatus(resp.status));
       }
       if (target.isGroup === true) {
         if (msgKey !== PROACTIVE_FILE_MSG_KEY) {
@@ -9861,7 +9971,7 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
     for (const state of reactionStates) {
       this.finishReaction(state.chatId, state.messageId, state.sessionId);
     }
-    this.statusCardController?.dispose();
+    const backgroundDrain = this.backgroundOutputCoordinator.drain();
     this.activeReactionKeys.clear();
     this.sessionReactionKeys.clear();
     this.reactionStates.clear();
@@ -9872,7 +9982,12 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
     }
     process.stderr.write(`[DingTalk:${this.name}] Disconnected.
 `);
-    this.disconnectDrain = Promise.allSettled(reactionStates.map((state) => state.tail)).then(() => void 0);
+    this.disconnectDrain = Promise.allSettled([
+      backgroundDrain,
+      ...reactionStates.map((state) => state.tail)
+    ]).then(() => {
+      this.statusCardController?.dispose();
+    });
   }
   waitForDisconnect() {
     return this.disconnectDrain ?? Promise.resolve();
@@ -10110,6 +10225,7 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
       }
     }
     this.sessionMentionTargets.delete(sessionId);
+    this.backgroundOutputCoordinator.drain(sessionId);
     const cardRunId = this.cardRunBySession.get(sessionId);
     if (cardRunId) {
       this.cardRunBySession.delete(sessionId);
@@ -10133,6 +10249,7 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
    * the sessions on a fresh bridge.
    */
   onBridgeDisconnected() {
+    void this.backgroundOutputCoordinator.drain();
     for (const [sessionId, keys] of this.sessionReactionKeys) {
       this.sessionReactionKeys.delete(sessionId);
       for (const { messageId, chatId } of keys.values()) {
@@ -10145,6 +10262,9 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
       this.cardRuns.delete(runId);
     }
   }
+  onSessionRetiring(sessionId) {
+    this.backgroundOutputCoordinator.drain(sessionId);
+  }
   onTaskLifecycle(event) {
     if (event.type === "started") {
       this.startReaction(event.chatId, event.messageId, event.sessionId);
@@ -10155,7 +10275,8 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
         this.cardRuns.set(event.runId, inboundOwner);
         this.cardRunBySession.set(event.sessionId, event.runId);
         const sourceLabel = this.getResponseSourceLabel(event.sessionId);
-        this.interactionPresenter?.registerRun(event.runId, event.owner.id, inboundOwner.target, event.sessionId, inboundOwner.sender, ...sourceLabel ? [sourceLabel] : []);
+        const atUserId = this.atSender && event.messageId ? this.mentionTargets.get(event.messageId) : void 0;
+        this.interactionPresenter?.registerRun(event.runId, event.owner.id, inboundOwner.target, event.sessionId, inboundOwner.sender, sourceLabel, (chatId, text, _sessionId, label) => this.sendReply(chatId, text, atUserId, label));
         this.interactionPresenter?.startStatusCard(event.runId);
       }
       return;
@@ -10281,11 +10402,138 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
     this.sessionMentionTargets.delete(sessionId);
     this.stopReaction(chatId, messageId, sessionId);
   }
-  async sendResponseMessage(chatId, text, sessionId, sourceLabel, prepared = false) {
+  async dispatchBackgroundResponse(sessionId, text, context) {
+    const target = this.router.getTarget(sessionId);
+    if (!target || target.channelName !== this.name) {
+      return super.dispatchBackgroundResponse(sessionId, text, context);
+    }
+    if (await this.backgroundOutputCoordinator.dispatch(sessionId, text, context)) {
+      return;
+    }
+    if (!text.trim())
+      return;
+    const delivery = await this.resolveBackgroundResponseDelivery(sessionId);
+    if (!delivery || this.router.getTarget(sessionId) !== delivery.target)
+      return;
+    await this.deliverBackgroundResponseToTarget(sessionId, text, delivery, false, context);
+  }
+  createBackgroundOutputDelivery(sessionId, target) {
+    let proactivePlan;
+    let replyPlan;
+    let preparedReplyBody;
+    let composedHeader;
+    let composedTurnComplete = false;
+    return async (output) => {
+      const header = this.formatBackgroundOutputHeader(output);
+      const body = [header, output.text].filter(Boolean).join("\n\n");
+      const plan = proactivePlan ?? replyPlan;
+      if (!plan || plan.nextChunk === 0) {
+        const replaceHeader = /* @__PURE__ */ __name((text) => {
+          if (composedHeader === void 0 || composedHeader === header) {
+            return text;
+          }
+          const separator = output.text ? "\n\n" : "";
+          const previous = composedHeader ? `${composedHeader}${separator}` : "";
+          const next = header ? `${header}${separator}` : "";
+          return text.startsWith(previous) ? `${next}${text.slice(previous.length)}` : text;
+        }, "replaceHeader");
+        if (plan) {
+          plan.title = extractTitle(body);
+          const prefix = (replyPlan?.atUserId ? `@${replyPlan.atUserId}
+
+` : "") + (target.sourceLabel ? `${escapeDingTalkMarkdown(target.sourceLabel)}
+
+` : "");
+          plan.chunks[0] = prefix + replaceHeader(plan.chunks[0].slice(prefix.length));
+        }
+        if (preparedReplyBody) {
+          preparedReplyBody = replaceHeader(preparedReplyBody);
+        }
+        composedHeader = header;
+        composedTurnComplete = output.turnComplete;
+      }
+      try {
+        if (proactivePlan) {
+          await this.deliverProactiveText(target.target, proactivePlan);
+        } else if (replyPlan) {
+          await this.deliverReplyText(target.target.chatId, replyPlan, true);
+        } else {
+          if (this.statusCardController || !this.supportsProactiveSend() || !this.supportsProactiveTarget(target.target)) {
+            preparedReplyBody ??= await this.prepareBackgroundOutput(target.target, body);
+          }
+          await this.deliverBackgroundResponseToTarget(sessionId, preparedReplyBody ?? body, target, preparedReplyBody !== void 0, output);
+        }
+        return { turnComplete: composedTurnComplete };
+      } catch (error) {
+        if (error instanceof ProactiveTextDeliveryError) {
+          proactivePlan = error.plan;
+        } else if (error instanceof ReplyTextDeliveryError) {
+          replyPlan = error.plan;
+        }
+        throw error;
+      }
+    };
+  }
+  formatBackgroundOutputHeader(delivery) {
+    const chinese = isChinesePresentationLanguage(this.displayLanguage);
+    const partialLabel = partialOutputLabel(this.displayLanguage);
+    const icon = delivery.status === "completed" ? "\u2705" : delivery.status === "failed" ? "\u274C" : "\u23F9\uFE0F";
+    if (delivery.kind === "agent") {
+      if (delivery.text)
+        return delivery.partial ? partialLabel : "";
+      const status = delivery.status === "completed" ? chinese ? "\u5DF2\u5B8C\u6210" : "completed" : delivery.status === "failed" ? chinese ? "\u5931\u8D25" : "failed" : chinese ? "\u5DF2\u505C\u6B62" : "stopped";
+      return chinese ? `${icon} \u540E\u53F0\u4EFB\u52A1${status}` : `${icon} Background task ${status}`;
+    }
+    const label = this.formatBackgroundTaskLabel(delivery.label);
+    const kind = {
+      shell: "Shell",
+      monitor: "Monitor",
+      workflow: "Workflow"
+    }[delivery.kind];
+    return `## ${icon} ${kind} \xB7 ${label}${delivery.partial ? `${chinese ? "" : " "}${partialLabel}` : ""}`;
+  }
+  formatBackgroundTaskLabel(label) {
+    const normalized = label?.replace(new RegExp("\\p{Cc}+", "gu"), " ").replace(/\s+/g, " ").trim();
+    return escapeDingTalkMarkdown(normalized || (isChinesePresentationLanguage(this.displayLanguage) ? "\u540E\u53F0\u4EFB\u52A1" : "Background task"));
+  }
+  prepareBackgroundOutput(target, text) {
+    return this.supportsProactiveSend() && this.supportsProactiveTarget(target) ? this.prepareFileOutput(text, (file, mediaId) => this.sendProactiveFile(target, file, mediaId)) : this.prepareReplyOutput(target.chatId, text);
+  }
+  async deliverBackgroundResponseToTarget(sessionId, text, delivery, prepared = false, result) {
+    const { target, sourceLabel } = delivery;
+    if (this.statusCardController && this.supportsProactiveDeliveryTarget(target) && (target.isGroup === true || this.isStableTargetId(target.senderId))) {
+      if (!prepared) {
+        text = await this.prepareBackgroundOutput(target, text);
+        prepared = true;
+      }
+      if (await this.statusCardController.deliverCompletedResult({
+        chatId: target.isGroup ? target.chatId : target.senderId,
+        isGroup: target.isGroup === true
+      }, text, sourceLabel, result)) {
+        return;
+      }
+    }
+    if (this.supportsProactiveSend() && this.supportsProactiveTarget(target)) {
+      return super.deliverBackgroundResponseToTarget(sessionId, text, delivery);
+    }
+    await this.deliverBackgroundReply(target.chatId, text, sessionId, sourceLabel, prepared, true);
+  }
+  /**
+   * Body-identical to the base implementation — this override exists only to
+   * widen the signature, which the base seam does not declare. The background
+   * output delivery passes `prepared` so the body it already projected isn't
+   * projected a second time (that would re-upload its files), and
+   * `failOnHttpError` so a failed send throws instead of being swallowed,
+   * letting the flush capture the delivery plan for the next retry.
+   */
+  async deliverBackgroundReply(chatId, text, sessionId, sourceLabel, prepared = false, failOnHttpError = false) {
+    await this.sendResponseMessage(chatId, text, sessionId, sourceLabel, prepared, failOnHttpError);
+  }
+  async sendResponseMessage(chatId, text, sessionId, sourceLabel, prepared = false, failOnHttpError = false) {
     const atUserId = this.atSender ? this.sessionMentionTargets.get(sessionId) : void 0;
     if (atUserId)
       this.sessionMentionTargets.delete(sessionId);
-    await this.sendReply(chatId, text, atUserId, sourceLabel ?? this.getResponseSourceLabel(sessionId), prepared);
+    await this.sendReply(chatId, text, atUserId, sourceLabel ?? this.getResponseSourceLabel(sessionId), prepared, failOnHttpError);
   }
   async sendFallbackReply(chatId, text, sessionId, sourceLabel) {
     const atUserId = this.atSender ? this.sessionMentionTargets.get(sessionId) : void 0;
@@ -10301,7 +10549,7 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
         return;
       }
     }
-    await this.sendResponseMessage(chatId, outgoingText, sessionId, segment?.sourceLabel, true);
+    await this.sendResponseMessage(chatId, segment?.partial ? markPartialOutput(outgoingText, this.displayLanguage) : outgoingText, sessionId, segment?.sourceLabel, true);
   }
   onOutputSegmentEnd(_chatId, _sessionId, segment, reason) {
     if (reason === "completed" || reason === "failed" || reason === "cancelled") {
@@ -10727,6 +10975,7 @@ var plugin = {
   channelType: "dingtalk",
   displayName: "DingTalk",
   requiredConfigFields: ["clientId", "clientSecret"],
+  supportsOutputMode: true,
   management: {
     fields: [
       {