@qwen-code/qwen-code 0.23.1-preview.1 → 0.23.1-preview.2

package/chunks/{dist-MK5PPBRF.js → dist-P6YWBITG.js}

@@ -14,7 +14,7 @@ import {
   sanitizePromptText,
   sanitizeSenderName,
   truncateUtf16Units
-} from "./chunk-VDXYYVCD.js";
+} from "./chunk-65GHQ4FX.js";
 import "./chunk-IW6RQPQB.js";
 import "./chunk-CQ35AJ4Z.js";
 import "./chunk-DMTGGOSA.js";
@@ -8382,6 +8382,9 @@ ${boundedLines.join("\n")}`);
 }
 __name(formatChatRecord, "formatChatRecord");
 var DEDUP_TTL_MS = 5 * 60 * 1e3;
+var BACKGROUND_RESPONSE_AGGREGATION_TIMEOUT_MS = 10 * 60 * 1e3;
+var BACKGROUND_RESPONSE_AGGREGATION_RETRY_MS = 30 * 1e3;
+var BACKGROUND_RESPONSE_AGGREGATION_MAX_RETRIES = 3;
 var ACK_REACTION_NAME = "\u{1F440}";
 var ACK_EMOTION_ID = "2659900";
 var ACK_EMOTION_BG_ID = "im_bg_1";
@@ -8552,6 +8555,30 @@ 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;
+  constructor(plan, cause) {
+    super(cause instanceof Error ? cause.message : String(cause), { cause });
+    this.plan = plan;
+  }
+};
 var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
   static {
     __name(this, "DingtalkChannel");
@@ -8582,6 +8609,7 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
    */
   proactiveToken;
   interactiveCardConfig;
+  aggregateBackgroundAgentResponses;
   interactiveCardClient;
   statusCardController;
   questionCardController;
@@ -8601,6 +8629,10 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
   // must be dropped, because recreating state would post the tail of a
   // force-split [FILE: ...] marker verbatim.
   blockProjectionArmed = /* @__PURE__ */ new Set();
+  backgroundResponseAggregations = /* @__PURE__ */ new Map();
+  detachedBackgroundResponseAggregations = /* @__PURE__ */ new Set();
+  pendingBackgroundResponseTerminals = /* @__PURE__ */ new Map();
+  detachedPendingBackgroundResponseTerminals = /* @__PURE__ */ new Set();
   constructor(name, config, bridge, options) {
     super(name, config, bridge, options);
     this.atSender = config["atSender"] === true;
@@ -8618,6 +8650,11 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
       this.config.instructions += FILE_INSTRUCTIONS;
     }
     this.interactiveCardConfig = parseDingtalkInteractiveCardConfig(config.interactiveCards);
+    const rawAggregateBackgroundAgentResponses = config.aggregateBackgroundAgentResponses;
+    if (rawAggregateBackgroundAgentResponses !== void 0 && typeof rawAggregateBackgroundAgentResponses !== "boolean") {
+      throw new Error(`Channel "${name}" aggregateBackgroundAgentResponses must be a boolean.`);
+    }
+    this.aggregateBackgroundAgentResponses = rawAggregateBackgroundAgentResponses === true;
     if (!config.clientId || !config.clientSecret) {
       throw new Error(`Channel "${name}" requires clientId and clientSecret for DingTalk.`);
     }
@@ -9015,16 +9052,27 @@ 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);
+    try {
+      await this.deliverReplyText(chatId, plan, failOnHttpError);
+    } catch (error) {
+      throw new ReplyTextDeliveryError(plan, error);
+    }
+  }
+  createReplyTextDelivery(outgoingText, atUserId, sourceLabel) {
     const mentionPrefix = atUserId ? `@${atUserId}
 
 ` : "";
@@ -9036,17 +9084,32 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
       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];
-      const isMention = i === 0 && atUserId !== void 0;
+    return {
+      title: extractTitle(outgoingText),
+      chunks,
+      nextChunk: 0,
+      ...atUserId ? { atUserId } : {}
+    };
+  }
+  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) {
+      const index = plan.nextChunk;
+      const chunk = plan.chunks[index];
+      const isMention = index === 0 && plan.atUserId !== void 0;
       const body = {
         msgtype: "markdown",
         markdown: {
-          title: i === 0 ? title : `${title} (cont.)`,
+          title: index === 0 ? plan.title : `${plan.title} (cont.)`,
           text: chunk
         },
-        ...isMention ? { at: { atUserIds: [atUserId] } } : {}
+        ...isMention ? { at: { atUserIds: [plan.atUserId] } } : {}
       };
       let resp;
       try {
@@ -9073,7 +9136,21 @@ 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 Error(`DingTalk reply send failed: HTTP ${resp.status} ${detail}`);
+        }
+      } 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++;
     }
   }
   async sendMessage(chatId, text) {
@@ -9103,9 +9180,19 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
   async pushProactive(target, text, sourceLabel) {
     if (!text.trim())
       return;
+    const plan = await this.createProactiveTextDelivery(target, text, sourceLabel);
+    if (!plan)
+      return;
+    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));
     if (!outgoingText.trim())
-      return;
+      return void 0;
     const sourcePrefix = sourceLabel ? `${escapeDingTalkMarkdown(sourceLabel)}
 
 ` : "";
@@ -9114,9 +9201,13 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
       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}`);
+    return { title: extractTitle(outgoingText), chunks, nextChunk: 0 };
+  }
+  async deliverProactiveText(target, plan) {
+    while (plan.nextChunk < plan.chunks.length) {
+      const index = plan.nextChunk;
+      await this.sendProactiveChunk(target, index === 0 ? plan.title : `${plan.title} (cont.)`, plan.chunks[index], `chunk ${index + 1}/${plan.chunks.length}`);
+      plan.nextChunk++;
     }
   }
   async getProactiveToken() {
@@ -9316,6 +9407,7 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
       clearInterval(this.dedupTimer);
     }
     this.statusCardController?.dispose();
+    this.drainBackgroundResponseAggregations();
     this.activeReactionKeys.clear();
     this.sessionReactionKeys.clear();
     if (this.connectionManager) {
@@ -9409,6 +9501,7 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
       }
     }
     this.sessionMentionTargets.delete(sessionId);
+    this.drainBackgroundResponseAggregations(sessionId);
     const cardRunId = this.cardRunBySession.get(sessionId);
     if (cardRunId) {
       this.cardRunBySession.delete(sessionId);
@@ -9428,6 +9521,9 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
     }
     super.onSessionDied(sessionId);
   }
+  onSessionRetiring(sessionId) {
+    this.drainBackgroundResponseAggregations(sessionId);
+  }
   onTaskLifecycle(event) {
     if (event.type === "started") {
       this.startReaction(event.chatId, event.messageId, event.sessionId);
@@ -9583,18 +9679,569 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
 `);
     });
   }
+  /** Deliver every Agent segment immediately unless aggregation is enabled. */
+  async dispatchBackgroundResponse(sessionId, text, context) {
+    const target = this.router.getTarget(sessionId);
+    if (!target || target.channelName !== this.name || context !== void 0 && context.kind !== "agent") {
+      return super.dispatchBackgroundResponse(sessionId, text, context);
+    }
+    const canAggregate = this.aggregateBackgroundAgentResponses && context?.kind === "agent" && typeof context.turnComplete === "boolean";
+    if (!canAggregate) {
+      if (text.trim().length === 0) {
+        return super.dispatchBackgroundResponse(sessionId, text, context);
+      }
+      return super.dispatchBackgroundResponse(sessionId, this.formatBackgroundAgentResponse(text, context?.label), context);
+    }
+    const key = JSON.stringify([sessionId, context.taskId, context.turnId]);
+    let current = this.backgroundResponseAggregations.get(key);
+    let parked = this.pendingBackgroundResponseTerminals.get(key);
+    if (current?.turnComplete === true) {
+      this.detachedBackgroundResponseAggregations.add(current);
+      this.backgroundResponseAggregations.delete(key);
+      current = void 0;
+    }
+    if (!current && (parked?.turnEnded === true || parked?.turnComplete === true && (parked.retryTimer || parked.retryInFlight || parked.resolvers > 0))) {
+      if (!parked.turnEnded) {
+        this.detachedPendingBackgroundResponseTerminals.add(parked);
+      }
+      parked = { sessionId, target, resolvers: 0, held: [] };
+      this.pendingBackgroundResponseTerminals.set(key, parked);
+    }
+    if (!current && text.trim().length === 0) {
+      if (!parked || parked.resolvers === 0 && !parked.retryTimer && !parked.retryInFlight && !parked.resolutionDropped && !parked.turnComplete) {
+        if (parked)
+          this.pendingBackgroundResponseTerminals.delete(key);
+        return super.dispatchBackgroundResponse(sessionId, text, context);
+      }
+      if (context.turnComplete) {
+        parked.turnComplete = true;
+        parked.status = context.status;
+        parked.label = context.label ?? parked.label;
+        parked.completionPartial = context.partial === true;
+        if (parked.resolvers === 0 && !parked.retryTimer && !parked.retryInFlight && (parked.retryAttempts ?? 0) >= BACKGROUND_RESPONSE_AGGREGATION_MAX_RETRIES) {
+          parked.turnEnded = true;
+          this.pendingBackgroundResponseTerminals.delete(key);
+        }
+      }
+      return;
+    }
+    if (!current) {
+      parked ??= { sessionId, target, resolvers: 0, held: [] };
+      this.pendingBackgroundResponseTerminals.set(key, parked);
+      this.holdPendingBackgroundResponse(parked, text, context);
+      parked.resolvers++;
+      try {
+        let delivery;
+        try {
+          delivery = await this.resolveBackgroundResponseDelivery(sessionId);
+        } catch (error) {
+          if (parked.resolvers === 1 && !this.backgroundResponseAggregations.has(key)) {
+            this.scheduleBackgroundResponseResolutionRetry(key, sessionId, parked);
+          } else {
+            const existing = this.backgroundResponseAggregations.get(key);
+            if (existing) {
+              if (parked.held.length > 0) {
+                this.applyHeldBackgroundResponses(existing, parked);
+              }
+              this.applyPendingBackgroundResponseTerminal(existing, parked);
+              if (parked.resolvers === 1) {
+                if (existing.turnComplete) {
+                  await this.completeBackgroundResponseAggregation(key, existing);
+                } else {
+                  this.scheduleBackgroundResponseAggregationFlush(key, existing);
+                }
+              }
+            }
+          }
+          throw error;
+        }
+        if (!delivery || this.router.getTarget(sessionId) !== delivery.target) {
+          if (parked.resolvers === 1 && !this.backgroundResponseAggregations.has(key)) {
+            this.scheduleBackgroundResponseResolutionRetry(key, sessionId, parked);
+          } else {
+            const existing = this.backgroundResponseAggregations.get(key);
+            if (existing) {
+              if (parked.held.length > 0) {
+                this.applyHeldBackgroundResponses(existing, parked);
+              }
+              this.applyPendingBackgroundResponseTerminal(existing, parked);
+              if (parked.resolvers === 1) {
+                if (existing.turnComplete) {
+                  await this.completeBackgroundResponseAggregation(key, existing);
+                } else {
+                  this.scheduleBackgroundResponseAggregationFlush(key, existing);
+                }
+              }
+            }
+          }
+          return;
+        }
+        if (parked.retiring || this.pendingBackgroundResponseTerminals.get(key) !== parked) {
+          await this.flushDetachedBackgroundResponse(key, sessionId, parked, delivery);
+          return;
+        }
+        if (parked.retryTimer) {
+          clearTimeout(parked.retryTimer);
+          parked.retryTimer = void 0;
+        }
+        current = this.backgroundResponseAggregations.get(key) ?? this.createBackgroundResponseAggregation(key, sessionId, parked.held[0]?.context ?? context, delivery.target, delivery.sourceLabel);
+        this.applyHeldBackgroundResponses(current, parked);
+        this.applyPendingBackgroundResponseTerminal(current, parked);
+        if (parked.resolutionDropped) {
+          current.resolutionDropped = true;
+          parked.resolutionDropped = void 0;
+        }
+      } finally {
+        parked.resolvers--;
+        if (this.pendingBackgroundResponseTerminals.get(key) === parked && parked.resolvers === 0 && !parked.retryTimer && parked.held.length === 0 && (!parked.resolutionDropped || parked.turnEnded)) {
+          this.pendingBackgroundResponseTerminals.delete(key);
+        }
+      }
+      if (!current)
+        return;
+      if (current.turnComplete && parked.resolvers > 0)
+        return;
+      if (!current.turnComplete) {
+        this.scheduleBackgroundResponseAggregationFlush(key, current);
+      } else {
+        await this.completeBackgroundResponseAggregation(key, current);
+      }
+      return;
+    }
+    current.status = context.status;
+    current.label = context.label ?? current.label;
+    if (text.trim().length > 0)
+      current.parts.push(text);
+    if (context.turnComplete && parked && parked.resolvers > 0) {
+      parked.turnComplete = true;
+      parked.status = context.status;
+      parked.label = context.label ?? parked.label;
+      parked.completionPartial = context.partial === true;
+    } else if (context.turnComplete) {
+      current.turnComplete = true;
+      current.completionPartial = context.partial === true;
+    } else if (parked?.turnComplete && parked.resolvers === 0) {
+      current.turnComplete = true;
+      current.status = parked.status ?? current.status;
+      current.label = parked.label ?? current.label;
+      current.completionPartial = parked.completionPartial === true;
+    }
+    current.resolutionDropped ||= parked?.resolutionDropped;
+    if (!current.turnComplete) {
+      this.scheduleBackgroundResponseAggregationFlush(key, current);
+      return;
+    }
+    await this.completeBackgroundResponseAggregation(key, current);
+  }
+  async flushBackgroundResponseAggregation(key, aggregation) {
+    if (this.backgroundResponseAggregations.get(key) !== aggregation && !this.detachedBackgroundResponseAggregations.has(aggregation) || aggregation.flushing) {
+      return;
+    }
+    this.refreshBackgroundResponseDelivery(aggregation);
+    if (aggregation.retryTimer)
+      clearTimeout(aggregation.retryTimer);
+    aggregation.retryTimer = void 0;
+    let delivery = aggregation.delivery;
+    if (!delivery) {
+      if (aggregation.parts.length === 0) {
+        if (!this.owesTerminalBackgroundResponseCard(aggregation)) {
+          if (aggregation.retiring || aggregation.turnComplete) {
+            this.removeBackgroundResponseAggregation(key, aggregation);
+          } else {
+            this.scheduleBackgroundResponseAggregationFlush(key, aggregation);
+          }
+          return;
+        }
+      }
+      if (aggregation.timeoutTimer)
+        clearTimeout(aggregation.timeoutTimer);
+      aggregation.timeoutTimer = void 0;
+      const parts = aggregation.parts.splice(0);
+      delivery = {
+        status: aggregation.status,
+        label: aggregation.label,
+        parts,
+        partial: this.isPartialBackgroundResponseDelivery(aggregation, parts.length),
+        attempts: 0,
+        composedTurnComplete: aggregation.turnComplete === true
+      };
+      aggregation.delivery = delivery;
+    }
+    const body = this.formatBackgroundResponseAggregation(delivery);
+    aggregation.flushing = true;
+    let error;
+    try {
+      if (delivery.proactivePlan) {
+        await this.deliverProactiveText(aggregation.target, delivery.proactivePlan);
+      } else if (delivery.replyPlan) {
+        await this.deliverReplyText(aggregation.target.chatId, delivery.replyPlan, true);
+      } else if (this.supportsProactiveSend() && this.supportsProactiveTarget(aggregation.target)) {
+        await this.deliverBackgroundResponseToTarget(aggregation.sessionId, body, {
+          target: aggregation.target,
+          sourceLabel: aggregation.sourceLabel
+        });
+      } else {
+        delivery.preparedReplyBody ??= await this.prepareReplyOutput(aggregation.target.chatId, body);
+        await this.deliverBackgroundReply(aggregation.target.chatId, delivery.preparedReplyBody, aggregation.sessionId, aggregation.sourceLabel, true, true);
+      }
+    } catch (caught) {
+      error = caught;
+      if (caught instanceof ProactiveTextDeliveryError) {
+        delivery.proactivePlan = caught.plan;
+      } else if (caught instanceof ReplyTextDeliveryError) {
+        delivery.replyPlan = caught.plan;
+      }
+    } finally {
+      aggregation.flushing = false;
+    }
+    if (error === void 0) {
+      aggregation.delivery = void 0;
+      aggregation.delivered = true;
+      if (delivery.composedTurnComplete === true && aggregation.turnComplete && delivery.partial !== true && !aggregation.retiring) {
+        aggregation.completionDelivered = true;
+      }
+      if (aggregation.retiring || aggregation.turnComplete) {
+        await this.flushBackgroundResponseAggregation(key, aggregation);
+      } else {
+        this.scheduleBackgroundResponseAggregationFlush(key, aggregation);
+      }
+      return;
+    }
+    delivery.attempts++;
+    process.stderr.write(`[DingTalk:${this.name}] background response delivery failed (attempt ${delivery.attempts}): ${sanitizeLogText(error instanceof Error ? error.message : String(error), 300)}
+`);
+    if (delivery.attempts >= BACKGROUND_RESPONSE_AGGREGATION_MAX_RETRIES || // A permanently rejected send (an invalid appkey, a missing app) cannot
+    // succeed later; retrying it only spends the chat's send quota.
+    error instanceof ProactiveTextDeliveryError && error.retryable === false) {
+      aggregation.delivery = void 0;
+      aggregation.dropped = true;
+      if (aggregation.parts.length === 0) {
+        if (aggregation.retiring || aggregation.turnComplete) {
+          this.removeBackgroundResponseAggregation(key, aggregation);
+        } else {
+          this.scheduleBackgroundResponseAggregationFlush(key, aggregation);
+        }
+      } else if (aggregation.retiring || aggregation.turnComplete) {
+        await this.flushBackgroundResponseAggregation(key, aggregation);
+      } else {
+        this.scheduleBackgroundResponseAggregationFlush(key, aggregation);
+      }
+      return;
+    }
+    aggregation.retryTimer = setTimeout(() => {
+      aggregation.retryTimer = void 0;
+      void this.flushBackgroundResponseAggregation(key, aggregation);
+    }, BACKGROUND_RESPONSE_AGGREGATION_RETRY_MS);
+    aggregation.retryTimer.unref?.();
+  }
+  /**
+   * A card carries `（部分）` whenever it is not the turn's whole output: the
+   * turn is still open, earlier text already went out (or was given up on),
+   * or the turn itself ended early.
+   */
+  isPartialBackgroundResponseDelivery(aggregation, partCount) {
+    return partCount > 0 && (aggregation.delivered === true || aggregation.dropped === true || aggregation.resolutionDropped === true || aggregation.retiring === true || aggregation.completionPartial === true || aggregation.turnComplete !== true);
+  }
+  /**
+   * A turn that outran the bounded wait had its text delivered under the
+   * `（部分）` label. When it then completes normally with nothing buffered,
+   * a header-only card is the only way the chat ever learns it finished.
+   */
+  owesTerminalBackgroundResponseCard(aggregation) {
+    return aggregation.turnComplete === true && aggregation.delivered === true && aggregation.completionDelivered !== true && aggregation.retiring !== true && aggregation.completionPartial !== true && aggregation.dropped !== true && aggregation.resolutionDropped !== true;
+  }
+  refreshBackgroundResponseDelivery(aggregation) {
+    const delivery = aggregation.delivery;
+    if (!delivery || aggregation.flushing)
+      return;
+    const plan = delivery.proactivePlan ?? delivery.replyPlan;
+    if (plan && plan.nextChunk > 0)
+      return;
+    const body = this.formatBackgroundResponseAggregation(delivery);
+    const header = body.split("\n", 1)[0];
+    const replaceHeader = /* @__PURE__ */ __name((text) => text.replace(/## (?:✅|❌|⏹️) Agent · [^\n]+/, () => header), "replaceHeader");
+    if (plan) {
+      plan.title = extractTitle(body);
+      plan.chunks[0] = replaceHeader(plan.chunks[0]);
+    }
+    if (delivery.preparedReplyBody) {
+      delivery.preparedReplyBody = replaceHeader(delivery.preparedReplyBody);
+    }
+    delivery.composedTurnComplete = aggregation.turnComplete === true;
+  }
+  removeBackgroundResponseAggregation(key, aggregation) {
+    if (this.backgroundResponseAggregations.get(key) === aggregation) {
+      this.backgroundResponseAggregations.delete(key);
+    }
+    this.detachedBackgroundResponseAggregations.delete(aggregation);
+  }
+  drainBackgroundResponseAggregations(sessionId) {
+    for (const [key, pending] of this.pendingBackgroundResponseTerminals) {
+      if (sessionId !== void 0 && pending.sessionId !== sessionId)
+        continue;
+      if (pending.retryTimer)
+        clearTimeout(pending.retryTimer);
+      pending.retryTimer = void 0;
+      pending.retiring = true;
+      pending.turnComplete = true;
+      pending.completionPartial = true;
+      this.pendingBackgroundResponseTerminals.delete(key);
+      this.detachedPendingBackgroundResponseTerminals.add(pending);
+    }
+    for (const pending of this.detachedPendingBackgroundResponseTerminals) {
+      if (sessionId !== void 0 && pending.sessionId !== sessionId)
+        continue;
+      if (pending.retryTimer)
+        clearTimeout(pending.retryTimer);
+      pending.retryTimer = void 0;
+      pending.retiring = true;
+      pending.turnComplete = true;
+      pending.completionPartial = true;
+      if (pending.held.length > 0 && this.router.getTarget(pending.sessionId) === pending.target) {
+        void this.flushDetachedBackgroundResponse("", pending.sessionId, pending, { target: pending.target }).catch((error) => {
+          process.stderr.write(`[DingTalk:${this.name}] background response delivery failed during drain: ${sanitizeLogText(error instanceof Error ? error.message : String(error), 300)}
+`);
+        });
+      } else if (pending.held.length > 0) {
+        process.stderr.write(`[DingTalk:${this.name}] background response target unavailable during drain; ${pending.held.length} buffered segment(s) discarded
+`);
+        pending.held.length = 0;
+        this.detachedPendingBackgroundResponseTerminals.delete(pending);
+      } else if (pending.held.length === 0) {
+        this.detachedPendingBackgroundResponseTerminals.delete(pending);
+      }
+    }
+    const aggregations = /* @__PURE__ */ new Set([
+      ...this.backgroundResponseAggregations.values(),
+      ...this.detachedBackgroundResponseAggregations
+    ]);
+    for (const aggregation of aggregations) {
+      if (sessionId !== void 0 && aggregation.sessionId !== sessionId) {
+        continue;
+      }
+      if (aggregation.timeoutTimer)
+        clearTimeout(aggregation.timeoutTimer);
+      if (aggregation.retryTimer)
+        clearTimeout(aggregation.retryTimer);
+      aggregation.timeoutTimer = void 0;
+      aggregation.retryTimer = void 0;
+      aggregation.retiring = true;
+      aggregation.turnComplete = true;
+      aggregation.completionPartial = true;
+      if (!aggregation.flushing) {
+        void this.flushBackgroundResponseAggregation(aggregation.key, aggregation);
+      }
+    }
+  }
+  createBackgroundResponseAggregation(key, sessionId, context, target, sourceLabel) {
+    const aggregation = {
+      key,
+      sessionId,
+      target,
+      sourceLabel,
+      status: context.status,
+      label: context.label,
+      parts: []
+    };
+    this.backgroundResponseAggregations.set(key, aggregation);
+    return aggregation;
+  }
+  scheduleBackgroundResponseResolutionRetry(key, sessionId, pending) {
+    if (pending.retiring)
+      return;
+    if (pending.retryTimer)
+      return;
+    pending.retryAttempts = (pending.retryAttempts ?? 0) + 1;
+    if (pending.retryAttempts >= BACKGROUND_RESPONSE_AGGREGATION_MAX_RETRIES) {
+      pending.resolutionDropped = true;
+      pending.turnEnded = pending.turnComplete === true;
+      pending.held.length = 0;
+      pending.turnComplete = void 0;
+      pending.status = void 0;
+      pending.label = void 0;
+      pending.completionPartial = void 0;
+      if (pending.turnEnded) {
+        this.detachedPendingBackgroundResponseTerminals.delete(pending);
+      }
+      return;
+    }
+    pending.retryTimer = setTimeout(() => {
+      pending.retryTimer = void 0;
+      pending.retryInFlight = true;
+      void this.retryBackgroundResponseResolution(key, sessionId, pending).catch((error) => {
+        process.stderr.write(`[DingTalk:${this.name}] background response target resolution failed: ${sanitizeLogText(error instanceof Error ? error.message : String(error), 300)}
+`);
+      }).finally(() => {
+        pending.retryInFlight = false;
+        if (pending.retiring || !pending.retryTimer && !pending.resolutionDropped) {
+          this.detachedPendingBackgroundResponseTerminals.delete(pending);
+        }
+        if (this.pendingBackgroundResponseTerminals.get(key) === pending && pending.resolvers === 0 && !pending.retryTimer && pending.held.length === 0 && (!pending.resolutionDropped || pending.turnEnded)) {
+          this.pendingBackgroundResponseTerminals.delete(key);
+        }
+      });
+    }, BACKGROUND_RESPONSE_AGGREGATION_RETRY_MS);
+    pending.retryTimer.unref?.();
+    const active = this.pendingBackgroundResponseTerminals.get(key);
+    if (!active || active === pending) {
+      this.pendingBackgroundResponseTerminals.set(key, pending);
+    }
+  }
+  async retryBackgroundResponseResolution(key, sessionId, pending) {
+    let delivery;
+    try {
+      delivery = await this.resolveBackgroundResponseDelivery(sessionId);
+    } catch (error) {
+      if (this.pendingBackgroundResponseTerminals.get(key) === pending && !this.backgroundResponseAggregations.has(key) || this.detachedPendingBackgroundResponseTerminals.has(pending)) {
+        this.scheduleBackgroundResponseResolutionRetry(key, sessionId, pending);
+      }
+      throw error;
+    }
+    if (!delivery || this.router.getTarget(sessionId) !== delivery.target) {
+      if (pending.retiring) {
+        if (pending.held.length > 0) {
+          process.stderr.write(`[DingTalk:${this.name}] background response target unavailable during drain; ${pending.held.length} buffered segment(s) discarded
+`);
+        }
+        pending.held.length = 0;
+        this.detachedPendingBackgroundResponseTerminals.delete(pending);
+        return;
+      }
+      if (this.pendingBackgroundResponseTerminals.get(key) === pending && !this.backgroundResponseAggregations.has(key) || this.detachedPendingBackgroundResponseTerminals.has(pending)) {
+        this.scheduleBackgroundResponseResolutionRetry(key, sessionId, pending);
+      }
+      return;
+    }
+    if (pending.retiring || this.pendingBackgroundResponseTerminals.get(key) !== pending || pending.turnComplete) {
+      await this.flushDetachedBackgroundResponse(key, sessionId, pending, delivery);
+      return;
+    }
+    const first = pending.held[0];
+    if (!first)
+      return;
+    const aggregation = this.createBackgroundResponseAggregation(key, sessionId, first.context, delivery.target, delivery.sourceLabel);
+    this.applyHeldBackgroundResponses(aggregation, pending);
+    if (pending.resolutionDropped) {
+      aggregation.resolutionDropped = true;
+      pending.resolutionDropped = void 0;
+    }
+    if (this.pendingBackgroundResponseTerminals.get(key) === pending) {
+      this.pendingBackgroundResponseTerminals.delete(key);
+    }
+    this.scheduleBackgroundResponseAggregationFlush(key, aggregation);
+  }
+  holdPendingBackgroundResponse(pending, text, context) {
+    if (text.trim().length > 0)
+      pending.held.push({ text, context });
+    if (context.turnComplete) {
+      pending.turnComplete = true;
+      pending.status = context.status;
+      pending.label = context.label ?? pending.label;
+      pending.completionPartial = context.partial === true;
+    }
+  }
+  applyHeldBackgroundResponses(aggregation, pending) {
+    for (const { text, context } of pending.held.splice(0)) {
+      aggregation.status = context.status;
+      aggregation.label = context.label ?? aggregation.label;
+      aggregation.parts.push(text);
+      if (context.turnComplete) {
+        aggregation.turnComplete = true;
+        aggregation.completionPartial = context.partial === true;
+      }
+    }
+  }
+  applyPendingBackgroundResponseTerminal(aggregation, pending) {
+    if (!pending.turnComplete)
+      return;
+    aggregation.turnComplete = true;
+    aggregation.status = pending.status ?? aggregation.status;
+    aggregation.label = pending.label ?? aggregation.label;
+    aggregation.completionPartial = pending.completionPartial === true;
+    pending.turnComplete = void 0;
+    pending.status = void 0;
+    pending.label = void 0;
+    pending.completionPartial = void 0;
+  }
+  async completeBackgroundResponseAggregation(key, aggregation) {
+    if (aggregation.delivery) {
+      aggregation.delivery.status = aggregation.status;
+      aggregation.delivery.label = aggregation.label ?? aggregation.delivery.label;
+      aggregation.delivery.partial = this.isPartialBackgroundResponseDelivery(aggregation, aggregation.delivery.parts.length) || aggregation.parts.length > 0;
+    }
+    if (aggregation.timeoutTimer)
+      clearTimeout(aggregation.timeoutTimer);
+    aggregation.timeoutTimer = void 0;
+    await this.flushBackgroundResponseAggregation(key, aggregation);
+  }
+  async flushDetachedBackgroundResponse(key, sessionId, pending, delivery) {
+    const first = pending.held[0];
+    if (!first) {
+      this.detachedPendingBackgroundResponseTerminals.delete(pending);
+      return;
+    }
+    const aggregation = {
+      key,
+      sessionId,
+      target: delivery.target,
+      sourceLabel: delivery.sourceLabel,
+      status: first.context.status,
+      label: first.context.label,
+      parts: [],
+      turnComplete: pending.turnComplete,
+      completionPartial: pending.completionPartial,
+      resolutionDropped: pending.resolutionDropped
+    };
+    this.applyHeldBackgroundResponses(aggregation, pending);
+    aggregation.status = pending.status ?? aggregation.status;
+    aggregation.label = pending.label ?? aggregation.label;
+    if (this.pendingBackgroundResponseTerminals.get(key) === pending) {
+      this.pendingBackgroundResponseTerminals.delete(key);
+    }
+    this.detachedPendingBackgroundResponseTerminals.delete(pending);
+    this.detachedBackgroundResponseAggregations.add(aggregation);
+    await this.flushBackgroundResponseAggregation(key, aggregation);
+  }
+  scheduleBackgroundResponseAggregationFlush(key, aggregation) {
+    if (aggregation.timeoutTimer || aggregation.delivery)
+      return;
+    aggregation.timeoutTimer = setTimeout(() => {
+      aggregation.timeoutTimer = void 0;
+      void this.flushBackgroundResponseAggregation(key, aggregation);
+    }, BACKGROUND_RESPONSE_AGGREGATION_TIMEOUT_MS);
+    aggregation.timeoutTimer.unref?.();
+  }
+  formatBackgroundResponseAggregation(delivery) {
+    const icon = delivery.status === "completed" ? "\u2705" : delivery.status === "failed" ? "\u274C" : "\u23F9\uFE0F";
+    const label = this.formatBackgroundAgentLabel(delivery.label);
+    const header = `## ${icon} Agent \xB7 ${label}${delivery.partial ? "\uFF08\u90E8\u5206\uFF09" : ""}`;
+    if (delivery.parts.length === 0)
+      return header;
+    return `${header}
+
+${delivery.parts.join("\n\n")}`;
+  }
+  formatBackgroundAgentResponse(text, label) {
+    return `## \u{1F916} Agent \xB7 ${this.formatBackgroundAgentLabel(label)}
+
+${text}`;
+  }
+  formatBackgroundAgentLabel(label) {
+    const normalized = label?.replace(new RegExp("\\p{Cc}+", "gu"), " ").replace(/\s+/g, " ").trim();
+    return escapeDingTalkMarkdown(normalized || "\u540E\u53F0\u4EFB\u52A1");
+  }
   /**
    * Out-of-turn one-shot sends (background responses) must not flow through
    * the session's block-streaming projector: a second sender interleaving with
    * mid-projection state can swallow the send or split a held marker.
    */
-  async deliverBackgroundReply(chatId, text, sessionId, sourceLabel) {
+  async deliverBackgroundReply(chatId, text, sessionId, sourceLabel, prepared = false, failOnHttpError = false) {
     if (this.config.blockStreaming !== "on") {
-      return super.deliverBackgroundReply(chatId, text, sessionId, sourceLabel);
+      return this.sendResponseMessage(chatId, text, sessionId, sourceLabel, prepared, failOnHttpError);
     }
-    await this.sendReply(chatId, text, void 0, sourceLabel);
+    await this.sendReply(chatId, text, void 0, sourceLabel, prepared, failOnHttpError);
   }
-  async sendResponseMessage(chatId, text, sessionId, sourceLabel, prepared = false) {
+  async sendResponseMessage(chatId, text, sessionId, sourceLabel, prepared = false, failOnHttpError = false) {
     let outgoingText = text;
     let consumesMention = true;
     if (this.config.blockStreaming === "on") {
@@ -9607,7 +10254,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), prepared);
+    await this.sendReply(chatId, outgoingText, atUserId, sourceLabel ?? this.getResponseSourceLabel(sessionId), prepared, failOnHttpError);
   }
   projectBlockStreamChunk(text, sessionId) {
     let state = this.blockFileProjectors.get(sessionId);
@@ -10069,6 +10716,12 @@ var plugin = {
         required: true,
         envResolvable: true
       },
+      {
+        key: "aggregateBackgroundAgentResponses",
+        label: "Aggregate Background Agent Responses",
+        kind: "boolean",
+        description: "Buffer each background Agent turn and send one labeled result instead of labeled segments"
+      },
       {
         key: "interactiveCards",
         label: "Interactive Cards",