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

package/dist/DingtalkAdapter.js

@@ -410,15 +410,6 @@ function formatChatRecord(content, budget = MAX_CHAT_RECORD_CHARS) {
 }
 /** Track seen msgIds to deduplicate retried callbacks. */
 const DEDUP_TTL_MS = 5 * 60 * 1000; // 5 minutes
-const BACKGROUND_RESPONSE_AGGREGATION_TIMEOUT_MS = 10 * 60 * 1000;
-/**
- * A failed aggregation delivery is retried rather than dropped: aggregating
- * concentrates a whole turn into one send, and the burst that makes a send
- * fail (several agents finishing at once against one chat quota) is exactly
- * when the whole result would be lost.
- */
-const BACKGROUND_RESPONSE_AGGREGATION_RETRY_MS = 30 * 1000;
-const BACKGROUND_RESPONSE_AGGREGATION_MAX_RETRIES = 3;
 const ACK_REACTION_NAME = '👀';
 const ACK_EMOTION_ID = '2659900';
 const ACK_EMOTION_BG_ID = 'im_bg_1';
@@ -631,24 +622,6 @@ async function withConnectLoggingSuppressed(connect) {
         }
     }
 }
-class ProactiveTextDeliveryError extends Error {
-    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;
-        }
-    }
-}
-class ReplyTextDeliveryError extends Error {
-    plan;
-    constructor(plan, cause) {
-        super(cause instanceof Error ? cause.message : String(cause), { cause });
-        this.plan = plan;
-    }
-}
 export class DingtalkChannel extends ChannelBase {
     client;
     atSender;
@@ -680,7 +653,6 @@ export class DingtalkChannel extends ChannelBase {
      */
     proactiveToken;
     interactiveCardConfig;
-    aggregateBackgroundAgentResponses;
     interactiveCardClient;
     statusCardController;
     questionCardController;
@@ -693,10 +665,6 @@ export 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 = new Map();
-    backgroundResponseAggregations = new Map();
-    detachedBackgroundResponseAggregations = new Set();
-    pendingBackgroundResponseTerminals = new Map();
-    detachedPendingBackgroundResponseTerminals = new Set();
     constructor(name, config, bridge, options) {
         super(name, config, bridge, options);
         this.atSender =
@@ -717,13 +685,6 @@ export class DingtalkChannel extends ChannelBase {
             this.config.instructions += FILE_INSTRUCTIONS;
         }
         this.interactiveCardConfig = parseDingtalkInteractiveCardConfig(config.interactiveCards);
-        const rawAggregateBackgroundAgentResponses = config.aggregateBackgroundAgentResponses;
-        if (rawAggregateBackgroundAgentResponses !== undefined &&
-            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.`);
         }
@@ -1157,14 +1118,11 @@ export 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) {
         // chatId is a conversationId — resolve to the latest sessionWebhook.
         const webhook = this.webhooks.get(chatId);
         if (!webhook) {
             process.stderr.write(`[DingTalk:${this.name}] No webhook for chatId ${chatId}, cannot send.\n`);
-            if (failOnHttpError) {
-                throw new Error('DingTalk session webhook unavailable');
-            }
             return;
         }
         const outgoingText = prepared
@@ -1173,12 +1131,7 @@ export class DingtalkChannel extends ChannelBase {
         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}\n\n` : '';
@@ -1197,12 +1150,9 @@ export 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) {
@@ -1247,24 +1197,6 @@ export class DingtalkChannel extends ChannelBase {
             if (!resp.ok) {
                 const detail = await resp.text().catch(() => '');
                 process.stderr.write(`[DingTalk:${this.name}] sendMessage failed: HTTP ${resp.status} ${detail}\n`);
-                if (failOnHttpError) {
-                    throw new Error(`DingTalk reply send failed: HTTP ${resp.status} ${detail}`);
-                }
-            }
-            else if (failOnHttpError) {
-                const payload = (await resp
-                    .clone()
-                    .json()
-                    .catch(() => undefined));
-                const response = payload && typeof payload === 'object'
-                    ? payload
-                    : undefined;
-                const value = response?.['errcode'] ?? response?.['code'];
-                if (value !== undefined && String(value) !== '0') {
-                    const detail = sanitizeLogText(String(response?.['errmsg'] ?? response?.['message'] ?? value), 300);
-                    process.stderr.write(`[DingTalk:${this.name}] sendMessage failed: ${detail}\n`);
-                    throw new Error(`DingTalk reply send failed: ${detail}`);
-                }
             }
             plan.nextChunk++;
         }
@@ -1305,12 +1237,7 @@ export 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));
@@ -1555,7 +1482,6 @@ export 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();
@@ -1835,11 +1761,6 @@ export class DingtalkChannel extends ChannelBase {
             }
         }
         this.sessionMentionTargets.delete(sessionId);
-        // A session dying after segments arrived but before the terminal signal is
-        // precisely the case the partial-card fallback exists for; dropping the
-        // buffer here would lose text the agent already produced, which the
-        // pre-aggregation code always delivered on arrival.
-        this.drainBackgroundResponseAggregations(sessionId);
         const cardRunId = this.cardRunBySession.get(sessionId);
         if (cardRunId) {
             this.cardRunBySession.delete(sessionId);
@@ -1875,9 +1796,6 @@ export 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);
@@ -2023,636 +1941,15 @@ export 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 !== undefined && context.kind !== 'agent')) {
+            (context !== undefined && 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 = undefined;
-        }
-        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) {
-            // The first segment's target resolution can suspend (named-session owner
-            // lock), so a turn's terminal marker may arrive before the aggregation
-            // exists. Park it instead of routing it to the empty-text early return,
-            // or the completed turn only surfaces via the bounded wait, mislabeled.
-            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 = undefined;
-                }
-                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 = undefined;
-                }
-            }
-            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 = undefined;
-        let delivery = aggregation.delivery;
-        if (!delivery) {
-            if (aggregation.parts.length === 0) {
-                // A turn whose text was already drained by the bounded wait still owes
-                // the user its completion: the last card it saw reads `（部分）`.
-                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 = undefined;
-            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 === undefined) {
-            aggregation.delivery = undefined;
-            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 {
-                // The turn is still open: keep the entry so its later segments re-join
-                // this one (and stay labelled `（部分）`), and re-arm the bounded wait
-                // so a silent turn is still reaped.
-                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)}\n`);
-        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 = undefined;
-            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 = undefined;
-            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 = (text) => text.replace(/## (?:✅|❌|⏹️) Agent · [^\n]+/, () => header);
-        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 !== undefined && pending.sessionId !== sessionId)
-                continue;
-            if (pending.retryTimer)
-                clearTimeout(pending.retryTimer);
-            pending.retryTimer = undefined;
-            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 !== undefined && pending.sessionId !== sessionId)
-                continue;
-            if (pending.retryTimer)
-                clearTimeout(pending.retryTimer);
-            pending.retryTimer = undefined;
-            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)}\n`);
-                });
-            }
-            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\n`);
-                pending.held.length = 0;
-                this.detachedPendingBackgroundResponseTerminals.delete(pending);
-            }
-            else if (pending.held.length === 0) {
-                this.detachedPendingBackgroundResponseTerminals.delete(pending);
-            }
-        }
-        const aggregations = new Set([
-            ...this.backgroundResponseAggregations.values(),
-            ...this.detachedBackgroundResponseAggregations,
-        ]);
-        for (const aggregation of aggregations) {
-            if (sessionId !== undefined && aggregation.sessionId !== sessionId) {
-                continue;
-            }
-            if (aggregation.timeoutTimer)
-                clearTimeout(aggregation.timeoutTimer);
-            if (aggregation.retryTimer)
-                clearTimeout(aggregation.retryTimer);
-            aggregation.timeoutTimer = undefined;
-            aggregation.retryTimer = undefined;
-            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 = undefined;
-            pending.status = undefined;
-            pending.label = undefined;
-            pending.completionPartial = undefined;
-            if (pending.turnEnded) {
-                this.detachedPendingBackgroundResponseTerminals.delete(pending);
-            }
-            return;
-        }
-        pending.retryTimer = setTimeout(() => {
-            pending.retryTimer = undefined;
-            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)}\n`);
-            })
-                .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\n`);
-                }
-                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 = undefined;
-        }
-        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 = undefined;
-        pending.status = undefined;
-        pending.label = undefined;
-        pending.completionPartial = undefined;
-    }
-    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 = undefined;
-        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 = undefined;
-            void this.flushBackgroundResponseAggregation(key, aggregation);
-        }, BACKGROUND_RESPONSE_AGGREGATION_TIMEOUT_MS);
-        aggregation.timeoutTimer.unref?.();
-    }
-    formatBackgroundResponseAggregation(delivery) {
-        const icon = delivery.status === 'completed'
-            ? '✅'
-            : delivery.status === 'failed'
-                ? '❌'
-                : '⏹️';
-        const label = this.formatBackgroundAgentLabel(delivery.label);
-        const header = `## ${icon} Agent · ${label}${delivery.partial ? '（部分）' : ''}`;
-        if (delivery.parts.length === 0)
-            return header;
-        return `${header}\n\n${delivery.parts.join('\n\n')}`;
+        return super.dispatchBackgroundResponse(sessionId, this.formatBackgroundAgentResponse(text, context?.label), context);
     }
     formatBackgroundAgentResponse(text, label) {
         return `## 🤖 Agent · ${this.formatBackgroundAgentLabel(label)}\n\n${text}`;
@@ -2664,24 +1961,13 @@ export class DingtalkChannel extends ChannelBase {
             .trim();
         return escapeDingTalkMarkdown(normalized || '后台任务');
     }
-    /**
-     * 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)
             : undefined;
         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) {
         // Mid-run fallbacks must not consume the prompt's mention target: the