@qwen-code/channel-dingtalk 0.22.3 → 0.23.0

package/dist/status-card-controller.d.ts

@@ -15,6 +15,7 @@ export declare class StatusCardController {
     private readonly recordsByOutTrack;
     private readonly segmentIdsByRun;
     private readonly terminalSegmentIds;
+    private disposed;
     constructor(options: StatusCardControllerOptions);
     ensure(segment: ChannelOutputSegmentContext, target: {
         chatId: string;
@@ -28,7 +29,9 @@ export declare class StatusCardController {
      * Whether a created, still-running status card is displaying content for
      * this segment. Awaits the in-flight creation so a boundary decision made
      * while creation is pending does not race it. A latched stream failure
-     * means the card can never show further content, so it is not live.
+     * means the card can never show further content, so it is not live. A
+     * creation that is backing off for a retry is not awaited either (see
+     * `awaitDelivery`).
      */
     isCardLive(segmentId: string): Promise<boolean>;
     /**
@@ -38,15 +41,35 @@ export declare class StatusCardController {
      * caller can fall back instead of claiming delivery.
      */
     flushPending(segmentId: string): Promise<boolean>;
+    abandon(segmentId: string): void;
+    /**
+     * Resolves once the card is known to be delivered (or not) without waiting
+     * through a creation backoff: `creationAttempt` is the failed attempt until
+     * the retry actually starts, so a boundary reached mid-backoff falls back
+     * to text while the retry keeps running for later output.
+     */
+    private awaitDelivery;
     private createRecord;
     complete(segmentId: string, text: string, retainedContent?: (content: string) => string): Promise<boolean>;
     fail(segmentId: string, error: string): void;
     cancelRun(runId: string, reason: ChannelTaskCancellationReason): void;
     claimStop(outTrackId: string, actorId: string): DingtalkCardCallbackResult;
     private create;
+    /**
+     * Sleeps for the next creation backoff. Resolves false when finalization or
+     * disposal abandons the creation so `ready` settles without waiting.
+     */
+    private waitForCreationRetry;
     private scheduleFlush;
     private flush;
     private finalize;
+    private attemptFinalization;
+    private scheduleStreamRetry;
+    private scheduleTerminalRetry;
+    private handleStreamFailure;
+    private retryDelay;
+    private removeRecord;
+    dispose(): void;
     private statusLine;
     private updateRunningStatus;
     private scheduleStatusRefresh;

package/dist/status-card-controller.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"status-card-controller.d.ts","sourceRoot":"","sources":["../src/status-card-controller.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,2BAA2B,EAC3B,6BAA6B,EAC9B,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAEL,KAAK,6BAA6B,EACnC,MAAM,8BAA8B,CAAC;AACtC,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,6BAA6B,CAAC;AAO9E,eAAO,MAAM,aAAa,QAAS,CAAC;AACpC,eAAO,MAAM,iBAAiB,iCAAiC,CAAC;AA4BhE,MAAM,WAAW,2BAA2B;IAC1C,MAAM,EAAE,6BAA6B,CAAC;IACtC,SAAS,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAC9D,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI,CAAC;CACnD;AASD,qBAAa,oBAAoB;IAMnB,OAAO,CAAC,QAAQ,CAAC,OAAO;IALpC,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAmC;IACpE,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAmC;IACrE,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAkC;IAClE,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAqB;gBAE3B,OAAO,EAAE,2BAA2B;IAEjE,MAAM,CACJ,OAAO,EAAE,2BAA2B,EACpC,MAAM,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,OAAO,CAAA;KAAE,GAC3C,IAAI;IAOP,OAAO,CACL,OAAO,EAAE,2BAA2B,EACpC,MAAM,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,OAAO,CAAA;KAAE,EAC5C,OAAO,EAAE,MAAM,GACd,IAAI;IAcP;;;;;OAKG;IACG,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAMrD;;;;;OAKG;IACG,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAgBvD,OAAO,CAAC,YAAY;IAsCpB,QAAQ,CACN,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,MAAM,EACZ,eAAe,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,MAAM,GAC5C,OAAO,CAAC,OAAO,CAAC;IAUnB,IAAI,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;IAI5C,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,6BAA6B,GAAG,IAAI;IAarE,SAAS,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,0BAA0B;YAmC5D,MAAM;IA0CpB,OAAO,CAAC,aAAa;IAYrB,OAAO,CAAC,KAAK;YAyCC,QAAQ;IA0EtB,OAAO,CAAC,UAAU;YAeJ,mBAAmB;IAwBjC,OAAO,CAAC,qBAAqB;CA2B9B"}
+{"version":3,"file":"status-card-controller.d.ts","sourceRoot":"","sources":["../src/status-card-controller.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,2BAA2B,EAC3B,6BAA6B,EAC9B,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAGL,KAAK,6BAA6B,EACnC,MAAM,8BAA8B,CAAC;AACtC,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,6BAA6B,CAAC;AAU9E,eAAO,MAAM,aAAa,QAAS,CAAC;AACpC,eAAO,MAAM,iBAAiB,iCAAiC,CAAC;AAkDhE,MAAM,WAAW,2BAA2B;IAC1C,MAAM,EAAE,6BAA6B,CAAC;IACtC,SAAS,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAC9D,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI,CAAC;CACnD;AASD,qBAAa,oBAAoB;IAOnB,OAAO,CAAC,QAAQ,CAAC,OAAO;IANpC,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAmC;IACpE,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAmC;IACrE,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAkC;IAClE,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAqB;IACxD,OAAO,CAAC,QAAQ,CAAS;gBAEI,OAAO,EAAE,2BAA2B;IAEjE,MAAM,CACJ,OAAO,EAAE,2BAA2B,EACpC,MAAM,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,OAAO,CAAA;KAAE,GAC3C,IAAI;IAQP,OAAO,CACL,OAAO,EAAE,2BAA2B,EACpC,MAAM,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,OAAO,CAAA;KAAE,EAC5C,OAAO,EAAE,MAAM,GACd,IAAI;IAgBP;;;;;;;OAOG;IACG,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAOrD;;;;;OAKG;IACG,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAuBvD,OAAO,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IAqBhC;;;;;OAKG;YACW,aAAa;IAK3B,OAAO,CAAC,YAAY;IA8CpB,QAAQ,CACN,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,MAAM,EACZ,eAAe,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,MAAM,GAC5C,OAAO,CAAC,OAAO,CAAC;IAUnB,IAAI,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;IAI5C,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,6BAA6B,GAAG,IAAI;IAcrE,SAAS,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,0BAA0B;YAoC5D,MAAM;IAqDpB;;;OAGG;IACH,OAAO,CAAC,oBAAoB;IAc5B,OAAO,CAAC,aAAa;IAkBrB,OAAO,CAAC,KAAK;YA4CC,QAAQ;YA0CR,mBAAmB;IA0DjC,OAAO,CAAC,mBAAmB;IAiB3B,OAAO,CAAC,qBAAqB;IAY7B,OAAO,CAAC,mBAAmB;IAoB3B,OAAO,CAAC,UAAU;IAOlB,OAAO,CAAC,YAAY;IAuBpB,OAAO,IAAI,IAAI;IAWf,OAAO,CAAC,UAAU;YAeJ,mBAAmB;IAiCjC,OAAO,CAAC,qBAAqB;CAiC9B"}

package/dist/status-card-controller.js

@@ -1,10 +1,13 @@
 import { randomUUID } from 'node:crypto';
-import { STATUS_CARD_TEMPLATE_ID, } from './interactive-card-client.js';
+import { STATUS_CARD_TEMPLATE_ID, isRetryableDingtalkCardError, } from './interactive-card-client.js';
 import { sanitizeStreamingImageMarkers } from './outbound-image.js';
 const FLUSH_INTERVAL_MS = 500;
 const STATUS_REFRESH_INTERVAL_MS = 1_000;
+const CONTENT_SYNC_INTERVAL_SECONDS = 5;
 const BREAKER_PROBE_INTERVAL_MS = 30_000;
 const MAX_CONSECUTIVE_STATUS_FAILURES = 3;
+const INITIAL_RETRY_INTERVAL_MS = 1_000;
+const MAX_RETRY_INTERVAL_MS = 30_000;
 export const CONTENT_LIMIT = 20_000;
 export const TRUNCATION_MARKER = '[Earlier output truncated]\n';
 function boundContent(content) {
@@ -18,10 +21,13 @@ export class StatusCardController {
     recordsByOutTrack = new Map();
     segmentIdsByRun = new Map();
     terminalSegmentIds = new Set();
+    disposed = false;
     constructor(options) {
         this.options = options;
     }
     ensure(segment, target) {
+        if (this.disposed)
+            return;
         if (this.terminalSegmentIds.has(segment.segmentId))
             return;
         if (!this.recordsBySegment.has(segment.segmentId)) {
@@ -29,6 +35,8 @@ export class StatusCardController {
         }
     }
     replace(segment, target, content) {
+        if (this.disposed)
+            return;
         if (this.terminalSegmentIds.has(segment.segmentId))
             return;
         const record = this.recordsBySegment.get(segment.segmentId);
@@ -39,22 +47,27 @@ export class StatusCardController {
         if (record.terminal)
             return;
         record.content = boundContent(content);
+        record.contentVersion++;
         if (record.streamFailed)
             return;
-        record.pendingSnapshot = sanitizeStreamingImageMarkers(record.content);
+        record.hasPendingWrite = true;
         this.scheduleFlush(record);
     }
     /**
      * Whether a created, still-running status card is displaying content for
      * this segment. Awaits the in-flight creation so a boundary decision made
      * while creation is pending does not race it. A latched stream failure
-     * means the card can never show further content, so it is not live.
+     * means the card can never show further content, so it is not live. A
+     * creation that is backing off for a retry is not awaited either (see
+     * `awaitDelivery`).
      */
     async isCardLive(segmentId) {
+        if (this.disposed)
+            return false;
         const record = this.recordsBySegment.get(segmentId);
         if (!record || record.terminal || record.streamFailed)
             return false;
-        return record.ready;
+        return this.awaitDelivery(record);
     }
     /**
      * Drain any pending snapshot so callers can treat the card's current
@@ -63,23 +76,65 @@ export class StatusCardController {
      * caller can fall back instead of claiming delivery.
      */
     async flushPending(segmentId) {
+        if (this.disposed)
+            return false;
         const record = this.recordsBySegment.get(segmentId);
         if (!record || record.terminal)
             return false;
-        if (!(await record.ready))
+        if (!(await this.awaitDelivery(record)))
             return false;
         while (!record.terminal && !record.streamFailed) {
             if (record.flushTimer) {
                 clearTimeout(record.flushTimer);
                 record.flushTimer = undefined;
             }
+            if (record.streamRetryTimer) {
+                clearTimeout(record.streamRetryTimer);
+                record.streamRetryTimer = undefined;
+            }
+            const failureVersion = record.streamFailureVersion;
             this.flush(record);
             await record.writeChain;
-            if (record.pendingSnapshot === undefined)
+            if (record.streamFailureVersion !== failureVersion)
+                return false;
+            if (!record.hasPendingWrite)
                 break;
         }
         return !record.terminal && !record.streamFailed;
     }
+    abandon(segmentId) {
+        const record = this.recordsBySegment.get(segmentId);
+        if (!record || record.terminal)
+            return;
+        record.terminal = true;
+        record.hasPendingWrite = false;
+        void record.ready.then((ready) => {
+            if (!ready)
+                return;
+            void this.options.client
+                .updateInstance({
+                outTrackId: record.outTrackId,
+                cardParamMap: {
+                    flowStatus: 3,
+                    hasAction: 'false',
+                    stop_action: 'false',
+                },
+            })
+                .catch(() => { });
+        });
+        this.removeRecord(record);
+    }
+    /**
+     * Resolves once the card is known to be delivered (or not) without waiting
+     * through a creation backoff: `creationAttempt` is the failed attempt until
+     * the retry actually starts, so a boundary reached mid-backoff falls back
+     * to text while the retry keeps running for later output.
+     */
+    async awaitDelivery(record) {
+        if (!(await record.creationAttempt))
+            return false;
+        return record.ready;
+    }
     createRecord(segment, target, initialContent = '') {
         const outTrackId = `qwen-status-${randomUUID()}`;
         const record = {
@@ -92,13 +147,21 @@ export class StatusCardController {
             content: boundContent(initialContent),
             startedAt: Date.now(),
             lastStatusSecond: 0,
+            lastContentSyncSecond: 0,
             ready: Promise.resolve(false),
+            creationAttempt: Promise.resolve(false),
             terminal: false,
             streamFailed: false,
+            streamFailureVersion: 0,
+            createRetryAttempt: 0,
+            streamRetryAttempt: 0,
+            terminalRetryAttempt: 0,
             consecutiveStatusFailures: 0,
             stopClaimed: false,
             forbiddenActors: new Set(),
             lastWriteAt: Date.now(),
+            contentVersion: 0,
+            hasPendingWrite: false,
             writeChain: Promise.resolve(),
         };
         this.recordsBySegment.set(record.segmentId, record);
@@ -120,6 +183,8 @@ export class StatusCardController {
         void this.finalize(segmentId, boundContent(error), 'Failed', true);
     }
     cancelRun(runId, reason) {
+        if (this.disposed)
+            return;
         for (const segmentId of [...(this.segmentIdsByRun.get(runId) ?? [])]) {
             const record = this.recordsBySegment.get(segmentId);
             if (!record)
@@ -128,6 +193,8 @@ export class StatusCardController {
         }
     }
     claimStop(outTrackId, actorId) {
+        if (this.disposed)
+            return { kind: 'ignored', actorId };
         const record = this.recordsByOutTrack.get(outTrackId);
         if (!record || record.terminal || record.stopClaimed) {
             return { kind: 'ignored', actorId };
@@ -157,46 +224,79 @@ export class StatusCardController {
         };
     }
     async create(record, target) {
-        try {
-            const initialContent = sanitizeStreamingImageMarkers(record.content);
-            await this.options.client.createAndDeliver({
-                templateId: STATUS_CARD_TEMPLATE_ID,
-                outTrackId: record.outTrackId,
-                target,
-                cardParamMap: {
-                    content: initialContent,
-                    flowStatus: 2,
-                    statusLine: this.statusLine(record, 'Running').text,
-                    hasAction: 'true',
-                    stop_action: 'true',
-                },
+        for (;;) {
+            let settleAttempt;
+            record.creationAttempt = new Promise((resolve) => {
+                settleAttempt = resolve;
             });
+            try {
+                await this.options.client.createAndDeliver({
+                    templateId: STATUS_CARD_TEMPLATE_ID,
+                    outTrackId: record.outTrackId,
+                    target,
+                    cardParamMap: {
+                        content: sanitizeStreamingImageMarkers(record.content),
+                        flowStatus: 2,
+                        statusLine: this.statusLine(record, 'Running').text,
+                        hasAction: 'true',
+                        stop_action: 'true',
+                    },
+                });
+                settleAttempt(true);
+                break;
+            }
+            catch (error) {
+                settleAttempt(false);
+                this.options.onError?.('status card creation', error);
+                if (this.disposed ||
+                    record.terminal ||
+                    !isRetryableDingtalkCardError(error)) {
+                    return false;
+                }
+                if (!(await this.waitForCreationRetry(record)))
+                    return false;
+            }
+        }
+        if (this.disposed)
+            return false;
+        if (this.recordsBySegment.get(record.segmentId) !== record)
+            return true;
+        try {
             await this.options.client.openOrUpdateStream({
                 outTrackId: record.outTrackId,
                 key: 'content',
-                content: initialContent,
+                content: sanitizeStreamingImageMarkers(record.content),
                 finalize: false,
             });
-            return true;
         }
         catch (error) {
-            this.options.onError?.('status card creation', error);
-            await this.options.client
-                .updateInstance({
-                outTrackId: record.outTrackId,
-                cardParamMap: {
-                    flowStatus: 3,
-                    statusLine: 'Unavailable',
-                    hasAction: 'false',
-                    stop_action: 'false',
-                },
-            })
-                .catch(() => { });
-            return false;
+            this.handleStreamFailure(record, error);
         }
+        return true;
+    }
+    /**
+     * Sleeps for the next creation backoff. Resolves false when finalization or
+     * disposal abandons the creation so `ready` settles without waiting.
+     */
+    waitForCreationRetry(record) {
+        const delay = this.retryDelay(record.createRetryAttempt++);
+        return new Promise((resolve) => {
+            const settle = (resumed) => {
+                if (record.createRetryTimer)
+                    clearTimeout(record.createRetryTimer);
+                record.createRetryTimer = undefined;
+                record.abandonCreation = undefined;
+                resolve(resumed);
+            };
+            record.abandonCreation = () => settle(false);
+            record.createRetryTimer = setTimeout(() => settle(true), delay);
+        });
     }
     scheduleFlush(record) {
-        if (record.flushTimer || record.inFlight || record.terminal)
+        if (record.flushTimer ||
+            record.streamRetryTimer ||
+            record.inFlight ||
+            record.terminal)
             return;
         const delay = Math.max(0, FLUSH_INTERVAL_MS - (Date.now() - record.lastWriteAt));
         record.flushTimer = setTimeout(() => {
@@ -205,46 +305,50 @@ export class StatusCardController {
         }, delay);
     }
     flush(record) {
-        if (record.terminal ||
+        if (this.disposed ||
+            record.terminal ||
+            record.streamFailed ||
             record.inFlight ||
-            record.pendingSnapshot === undefined)
+            !record.hasPendingWrite)
             return;
-        const content = record.pendingSnapshot;
-        record.pendingSnapshot = undefined;
+        record.hasPendingWrite = false;
+        let sentVersion;
+        let contentWritten = false;
         const write = record.writeChain
             .then(async () => {
             const ready = await record.ready;
-            if (!ready || record.terminal)
+            if (!ready || record.terminal || record.streamFailed)
                 return;
+            sentVersion = record.contentVersion;
             await this.options.client.openOrUpdateStream({
                 outTrackId: record.outTrackId,
                 key: 'content',
-                content,
+                content: sanitizeStreamingImageMarkers(record.content),
                 finalize: false,
             });
+            contentWritten = true;
+            record.streamRetryAttempt = 0;
             await this.updateRunningStatus(record);
         })
-            .catch((error) => {
-            record.streamFailed = true;
-            record.pendingSnapshot = undefined;
-            if (record.statusTimer) {
-                clearTimeout(record.statusTimer);
-                record.statusTimer = undefined;
-            }
-            this.options.onError?.('status card streaming', error);
-        });
+            .catch((error) => this.handleStreamFailure(record, error));
         const tracked = write.finally(() => {
             if (record.inFlight === tracked) {
                 record.inFlight = undefined;
             }
             record.lastWriteAt = Date.now();
-            if (record.pendingSnapshot !== undefined)
+            if (contentWritten && record.contentVersion === sentVersion) {
+                record.hasPendingWrite = false;
+            }
+            if (record.hasPendingWrite && record.contentVersion !== sentVersion) {
                 this.scheduleFlush(record);
+            }
         });
         record.inFlight = tracked;
         record.writeChain = tracked;
     }
     async finalize(segmentId, content, state, isError, retainedContent) {
+        if (this.disposed)
+            return false;
         const record = this.recordsBySegment.get(segmentId);
         if (!record || record.terminal)
             return false;
@@ -259,61 +363,175 @@ export class StatusCardController {
         if (record.flushTimer)
             clearTimeout(record.flushTimer);
         record.flushTimer = undefined;
+        if (record.streamRetryTimer)
+            clearTimeout(record.streamRetryTimer);
+        record.streamRetryTimer = undefined;
         if (record.statusTimer)
             clearTimeout(record.statusTimer);
         record.statusTimer = undefined;
-        record.pendingSnapshot = undefined;
+        record.hasPendingWrite = false;
+        record.abandonCreation?.();
+        if (!(await record.ready)) {
+            this.removeRecord(record);
+            return false;
+        }
+        await record.writeChain;
+        const retained = content ||
+            (retainedContent ? retainedContent(record.content) : record.content);
+        record.terminalIntent = {
+            content: boundContent(sanitizeStreamingImageMarkers(retained)),
+            isError,
+            statusLine: this.statusLine(record, state).text,
+            streamFinalizeSettled: false,
+        };
+        return this.attemptFinalization(record);
+    }
+    async attemptFinalization(record) {
+        if (this.disposed)
+            return false;
+        if (this.recordsBySegment.get(record.segmentId) !== record)
+            return false;
+        const intent = record.terminalIntent;
+        if (!intent)
+            return false;
+        if (!intent.streamFinalizeSettled) {
+            try {
+                await this.options.client.openOrUpdateStream({
+                    outTrackId: record.outTrackId,
+                    key: 'content',
+                    content: '',
+                    finalize: true,
+                    isError: intent.isError,
+                });
+                intent.streamFinalizeSettled = true;
+            }
+            catch (error) {
+                if (!isRetryableDingtalkCardError(error)) {
+                    intent.streamFinalizeSettled = true;
+                }
+                this.options.onError?.('status card finalization', error);
+            }
+        }
+        if (this.disposed)
+            return false;
         try {
-            if (!(await record.ready))
-                return false;
-            await record.writeChain;
-            const retained = content ||
-                (retainedContent ? retainedContent(record.content) : record.content);
-            const finalContent = boundContent(sanitizeStreamingImageMarkers(retained));
-            await this.options.client.openOrUpdateStream({
-                outTrackId: record.outTrackId,
-                key: 'content',
-                content: '',
-                finalize: true,
-                isError,
-            });
             await this.options.client.updateInstance({
                 outTrackId: record.outTrackId,
                 cardParamMap: {
                     blockList: JSON.stringify([
                         {
                             type: 0,
-                            markdown: finalContent,
+                            markdown: intent.content,
                         },
                     ]),
-                    content: finalContent,
-                    copy_content: finalContent,
+                    content: intent.content,
+                    copy_content: intent.content,
                     flowStatus: 3,
-                    statusLine: this.statusLine(record, state).text,
+                    statusLine: intent.statusLine,
                     hasAction: 'false',
                     stop_action: 'false',
                 },
             });
             record.content = '';
+            this.removeRecord(record);
             return true;
         }
         catch (error) {
             this.options.onError?.('status card finalization', error);
-            return false;
-        }
-        finally {
-            if (this.recordsBySegment.get(segmentId) === record) {
-                this.recordsBySegment.delete(segmentId);
+            if (isRetryableDingtalkCardError(error)) {
+                this.scheduleTerminalRetry(record);
+                return true;
             }
-            if (this.recordsByOutTrack.get(record.outTrackId) === record) {
-                this.recordsByOutTrack.delete(record.outTrackId);
+            else {
+                this.removeRecord(record);
             }
-            const segmentIds = this.segmentIdsByRun.get(record.runId);
-            segmentIds?.delete(segmentId);
-            if (segmentIds?.size === 0) {
-                this.segmentIdsByRun.delete(record.runId);
+            return false;
+        }
+    }
+    scheduleStreamRetry(record) {
+        if (this.disposed ||
+            record.terminal ||
+            record.streamFailed ||
+            record.streamRetryTimer) {
+            return;
+        }
+        const delay = this.retryDelay(record.streamRetryAttempt++);
+        record.streamRetryTimer = setTimeout(() => {
+            record.streamRetryTimer = undefined;
+            if (this.disposed || record.terminal || record.streamFailed)
+                return;
+            this.flush(record);
+        }, delay);
+    }
+    scheduleTerminalRetry(record) {
+        if (this.disposed || !record.terminalIntent || record.terminalRetryTimer) {
+            return;
+        }
+        const delay = this.retryDelay(record.terminalRetryAttempt++);
+        record.terminalRetryTimer = setTimeout(() => {
+            record.terminalRetryTimer = undefined;
+            if (this.disposed)
+                return;
+            void this.attemptFinalization(record);
+        }, delay);
+    }
+    handleStreamFailure(record, error) {
+        record.streamFailureVersion++;
+        if (!this.disposed &&
+            !record.terminal &&
+            isRetryableDingtalkCardError(error)) {
+            record.hasPendingWrite = true;
+            this.scheduleStreamRetry(record);
+        }
+        else if (!record.terminal) {
+            record.streamFailed = true;
+            record.hasPendingWrite = false;
+            if (record.statusTimer) {
+                clearTimeout(record.statusTimer);
+                record.statusTimer = undefined;
             }
         }
+        this.options.onError?.('status card streaming', error);
+    }
+    retryDelay(attempt) {
+        return Math.min(INITIAL_RETRY_INTERVAL_MS * 2 ** Math.min(attempt, 10), MAX_RETRY_INTERVAL_MS);
+    }
+    removeRecord(record) {
+        record.abandonCreation?.();
+        if (record.flushTimer)
+            clearTimeout(record.flushTimer);
+        if (record.streamRetryTimer)
+            clearTimeout(record.streamRetryTimer);
+        if (record.terminalRetryTimer)
+            clearTimeout(record.terminalRetryTimer);
+        if (record.statusTimer)
+            clearTimeout(record.statusTimer);
+        record.flushTimer = undefined;
+        record.streamRetryTimer = undefined;
+        record.terminalRetryTimer = undefined;
+        record.statusTimer = undefined;
+        if (this.recordsBySegment.get(record.segmentId) === record) {
+            this.recordsBySegment.delete(record.segmentId);
+        }
+        if (this.recordsByOutTrack.get(record.outTrackId) === record) {
+            this.recordsByOutTrack.delete(record.outTrackId);
+        }
+        const segmentIds = this.segmentIdsByRun.get(record.runId);
+        segmentIds?.delete(record.segmentId);
+        if (segmentIds?.size === 0) {
+            this.segmentIdsByRun.delete(record.runId);
+        }
+    }
+    dispose() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        for (const record of [...this.recordsBySegment.values()]) {
+            record.terminal = true;
+            record.hasPendingWrite = false;
+            this.removeRecord(record);
+        }
+        this.terminalSegmentIds.clear();
     }
     statusLine(record, state) {
         const second = Math.max(0, Math.floor((Date.now() - record.startedAt) / 1000));
@@ -324,17 +542,26 @@ export class StatusCardController {
         };
     }
     async updateRunningStatus(record) {
-        if (record.terminal || record.streamFailed)
+        if (this.disposed || record.terminal || record.streamFailed)
             return;
         const status = this.statusLine(record, 'Running');
         if (status.second === record.lastStatusSecond)
             return;
+        const syncContent = status.second - record.lastContentSyncSecond >=
+            CONTENT_SYNC_INTERVAL_SECONDS;
         try {
             await this.options.client.updateInstance({
                 outTrackId: record.outTrackId,
-                cardParamMap: { statusLine: status.text },
+                cardParamMap: {
+                    ...(syncContent
+                        ? { content: sanitizeStreamingImageMarkers(record.content) }
+                        : {}),
+                    statusLine: status.text,
+                },
             });
             record.lastStatusSecond = status.second;
+            if (syncContent)
+                record.lastContentSyncSecond = status.second;
             record.consecutiveStatusFailures = 0;
             // A success revives the per-second chain even when only a low-frequency
             // breaker probe is scheduled.
@@ -350,13 +577,16 @@ export class StatusCardController {
         }
     }
     scheduleStatusRefresh(record, intervalMs = STATUS_REFRESH_INTERVAL_MS) {
-        if (record.terminal || record.streamFailed || record.statusTimer)
+        if (this.disposed ||
+            record.terminal ||
+            record.streamFailed ||
+            record.statusTimer)
             return;
         const elapsed = Math.max(0, Date.now() - record.startedAt);
         const delay = Math.max(50, intervalMs - (elapsed % intervalMs));
         record.statusTimer = setTimeout(() => {
             record.statusTimer = undefined;
-            if (record.terminal || record.streamFailed)
+            if (this.disposed || record.terminal || record.streamFailed)
                 return;
             const refresh = record.writeChain.then(() => this.updateRunningStatus(record));
             record.writeChain = refresh;