@qwen-code/qwen-code 0.23.2 → 0.23.3-nightly.20260911.aaa6a32aae

package/chunks/{dist-6YDUH3BB.js → dist-GIMQXYLI.js}

@@ -14,8 +14,8 @@ import {
   sanitizePromptText,
   sanitizeSenderName,
   truncateUtf16Units
-} from "./chunk-WDVV3LRM.js";
-import "./chunk-IW6RQPQB.js";
+} from "./chunk-EPVEPTI3.js";
+import "./chunk-IJOS26LH.js";
 import "./chunk-CQ35AJ4Z.js";
 import "./chunk-DMTGGOSA.js";
 import "./chunk-YQ3U5MUC.js";
@@ -8844,9 +8844,6 @@ ${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";
@@ -9043,30 +9040,6 @@ 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");
@@ -9101,7 +9074,6 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
    */
   proactiveToken;
   interactiveCardConfig;
-  aggregateBackgroundAgentResponses;
   interactiveCardClient;
   statusCardController;
   questionCardController;
@@ -9114,10 +9086,6 @@ 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;
@@ -9136,11 +9104,6 @@ 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.`);
     }
@@ -9552,25 +9515,18 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
     }
     return replaceImageMarkers(text, markers, replacements);
   }
-  async sendReply(chatId, text, atUserId, sourceLabel, prepared = false, failOnHttpError = false) {
+  async sendReply(chatId, text, atUserId, sourceLabel, prepared = false) {
     const webhook = this.webhooks.get(chatId);
     if (!webhook) {
       process.stderr.write(`[DingTalk:${this.name}] No webhook for chatId ${chatId}, cannot send.
 `);
-      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);
-    }
+    await this.deliverReplyText(chatId, plan);
   }
   createReplyTextDelivery(outgoingText, atUserId, sourceLabel) {
     const mentionPrefix = atUserId ? `@${atUserId}
@@ -9591,12 +9547,9 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
       ...atUserId ? { atUserId } : {}
     };
   }
-  async deliverReplyText(chatId, plan, failOnHttpError = false) {
+  async deliverReplyText(chatId, plan) {
     const webhook = this.webhooks.get(chatId);
     if (!webhook) {
-      if (failOnHttpError) {
-        throw new Error("DingTalk session webhook unavailable");
-      }
       return;
     }
     while (plan.nextChunk < plan.chunks.length) {
@@ -9636,19 +9589,6 @@ 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++;
     }
@@ -9683,11 +9623,7 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
     const plan = await this.createProactiveTextDelivery(target, text, sourceLabel);
     if (!plan)
       return;
-    try {
-      await this.deliverProactiveText(target, plan);
-    } catch (error) {
-      throw new ProactiveTextDeliveryError(plan, error);
-    }
+    await this.deliverProactiveText(target, plan);
   }
   async createProactiveTextDelivery(target, text, sourceLabel) {
     const outgoingText = await this.prepareFileOutput(text, (file, mediaId) => this.sendProactiveFile(target, file, mediaId));
@@ -9922,7 +9858,6 @@ 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();
@@ -10171,7 +10106,6 @@ 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);
@@ -10207,9 +10141,6 @@ 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);
@@ -10346,547 +10277,12 @@ 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") {
+    if (!target || target.channelName !== this.name || context !== void 0 && context.kind !== "agent" || !text.trim()) {
       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")}`;
+    return super.dispatchBackgroundResponse(sessionId, this.formatBackgroundAgentResponse(text, context?.label), context);
   }
   formatBackgroundAgentResponse(text, label) {
     return `## \u{1F916} Agent \xB7 ${this.formatBackgroundAgentLabel(label)}
@@ -10897,22 +10293,11 @@ ${text}`;
     const normalized = label?.replace(new RegExp("\\p{Cc}+", "gu"), " ").replace(/\s+/g, " ").trim();
     return escapeDingTalkMarkdown(normalized || "\u540E\u53F0\u4EFB\u52A1");
   }
-  /**
-   * 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) {
+  async sendResponseMessage(chatId, text, sessionId, sourceLabel, prepared = 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, failOnHttpError);
+    await this.sendReply(chatId, text, atUserId, sourceLabel ?? this.getResponseSourceLabel(sessionId), prepared);
   }
   async sendFallbackReply(chatId, text, sessionId, sourceLabel) {
     const atUserId = this.atSender ? this.sessionMentionTargets.get(sessionId) : void 0;
@@ -11363,12 +10748,6 @@ 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",