@qwen-code/qwen-code 0.23.3-nightly.20260910.c46cb85cf2 → 0.23.3

package/chunks/{dist-3BJVSJ7D.js → dist-AIKC5E5P.js}

@@ -14,7 +14,7 @@ import {
   sanitizePromptText,
   sanitizeSenderName,
   truncateUtf16Units
-} from "./chunk-C4NLHK7X.js";
+} from "./chunk-7QYWGTHB.js";
 import "./chunk-IJOS26LH.js";
 import "./chunk-CQ35AJ4Z.js";
 import "./chunk-DMTGGOSA.js";
@@ -8844,6 +8844,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";
@@ -9040,6 +9043,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");
@@ -9074,6 +9101,7 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
    */
   proactiveToken;
   interactiveCardConfig;
+  aggregateBackgroundAgentResponses;
   interactiveCardClient;
   statusCardController;
   questionCardController;
@@ -9086,6 +9114,10 @@ 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();
+  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;
@@ -9104,6 +9136,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.`);
     }
@@ -9515,18 +9552,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}
@@ -9547,9 +9591,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) {
@@ -9589,6 +9636,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 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++;
     }
@@ -9623,7 +9683,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));
@@ -9858,6 +9922,7 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
       this.finishReaction(state.chatId, state.messageId, state.sessionId);
     }
     this.statusCardController?.dispose();
+    this.drainBackgroundResponseAggregations();
     this.activeReactionKeys.clear();
     this.sessionReactionKeys.clear();
     this.reactionStates.clear();
@@ -10106,6 +10171,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);
@@ -10141,6 +10207,9 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
       this.cardRuns.delete(runId);
     }
   }
+  onSessionRetiring(sessionId) {
+    this.drainBackgroundResponseAggregations(sessionId);
+  }
   onTaskLifecycle(event) {
     if (event.type === "started") {
       this.startReaction(event.chatId, event.messageId, event.sessionId);
@@ -10277,12 +10346,547 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
     this.sessionMentionTargets.delete(sessionId);
     this.stopReaction(chatId, messageId, sessionId);
   }
+  /** 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" || !text.trim()) {
+    if (!target || target.channelName !== this.name || context !== void 0 && context.kind !== "agent") {
       return super.dispatchBackgroundResponse(sessionId, text, context);
     }
-    return super.dispatchBackgroundResponse(sessionId, this.formatBackgroundAgentResponse(text, context?.label), 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)}
@@ -10293,11 +10897,22 @@ ${text}`;
     const normalized = label?.replace(new RegExp("\\p{Cc}+", "gu"), " ").replace(/\s+/g, " ").trim();
     return escapeDingTalkMarkdown(normalized || "\u540E\u53F0\u4EFB\u52A1");
   }
-  async sendResponseMessage(chatId, text, sessionId, sourceLabel, prepared = false) {
+  /**
+   * Body-identical to the base implementation — this override exists only to
+   * widen the signature, which the base seam does not declare. The background
+   * aggregation flush 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;
@@ -10748,6 +11363,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",