@qwen-code/channel-feishu 0.21.7 → 0.21.8

package/dist/FeishuAdapter.js

@@ -4,11 +4,18 @@ import { randomUUID, timingSafeEqual } from 'node:crypto';
 import { basename, join } from 'node:path';
 import { tmpdir } from 'node:os';
 import * as lark from '@larksuiteoapi/node-sdk';
-import { ChannelBase, ChannelProactiveDeliveryError, isChannelProactiveDeliveryError, isTerminalTaskLifecycleType, } from '@qwen-code/channel-base';
+import { ChannelBase, ChannelProactiveDeliveryError, isChannelProactiveDeliveryError, isTerminalTaskLifecycleType, sanitizeSenderName, } from '@qwen-code/channel-base';
 import { buildCardContent, extractTitle, splitChunks } from './markdown.js';
 import { downloadMedia } from './media.js';
+import { FeishuQuestionCardController } from './question-card-controller.js';
 /** Track seen message IDs to deduplicate retried events. */
 const DEDUP_TTL_MS = 5 * 60 * 1000;
+/**
+ * Runtime label/lookup caches are bounded like the persisted observed-contact
+ * registry (500 observations) so a long-running daemon does not retain every
+ * user/chat/thread ID it ever sees.
+ */
+const OBSERVED_LABEL_CACHE_LIMIT = 500;
 /** Minimum interval between card updates (ms) to avoid API rate limiting. */
 const CARD_UPDATE_INTERVAL_MS = 1500;
 const FEISHU_RUNNING_STATUS_LABEL = '运行中...';
@@ -38,6 +45,19 @@ const FEISHU_STATUS_BLOCK_RE = new RegExp(`(?:^|\\n)---\\n\\*${FEISHU_STATUS_LAB
 const BASE_URL = 'https://open.feishu.cn/open-apis';
 /** Validate Feishu ID format to prevent SSRF path traversal in URL interpolation. */
 const FEISHU_ID_RE = /^[a-zA-Z0-9_.:-]+$/;
+/**
+ * Typed failure for interactive-card delivery. `detail` is set for HTTP
+ * failures so callers (createStreamingCard) can report by field instead of
+ * string-matching message literals that could drift under rewording.
+ */
+class FeishuCardDeliveryError extends Error {
+    detail;
+    constructor(message, detail) {
+        super(message);
+        this.detail = detail;
+        this.name = 'FeishuCardDeliveryError';
+    }
+}
 export class FeishuChannel extends ChannelBase {
     eventDispatcher;
     wsClient;
@@ -59,6 +79,16 @@ export class FeishuChannel extends ChannelBase {
     botOpenId;
     tokenCache;
     tokenRefreshPromise;
+    questionCardController;
+    // Core (non-silent) callers waiting on the shared token refresh, so a
+    // silent-initiated refresh still logs token errors for them.
+    tokenRefreshHasCoreWaiters = false;
+    observedUserNames = new Map();
+    observedChatNames = new Map();
+    observedUserLookups = new Map();
+    observedChatLookups = new Map();
+    observedContactWrites = new Map();
+    hydratedObservedNames = false;
     collapsible;
     collapsibleThreshold;
     constructor(name, config, bridge, options) {
@@ -70,6 +100,15 @@ export class FeishuChannel extends ChannelBase {
         this.collapsible = feishuCfg['collapsible'] || false;
         this.collapsibleThreshold =
             feishuCfg['collapsibleThreshold'] || 500;
+        this.questionCardController = new FeishuQuestionCardController({
+            timeoutMs: 270_000,
+            sendCard: (chatId, card) => this.sendInteractiveCard(chatId, card),
+            patchCard: (messageId, card) => this.patchInteractiveCard(messageId, card),
+            sendFallback: (chatId, text) => this.sendMessageInternal(chatId, text, true),
+            onError: (operation, error) => {
+                process.stderr.write(`[Feishu:${this.name}] ${operation} error: ${error instanceof Error ? error.message : error}\n`);
+            },
+        });
     }
     supportsProactiveSend() {
         return true;
@@ -85,6 +124,18 @@ export class FeishuChannel extends ChannelBase {
             'card.action.trigger': (data) => {
                 const payload = data;
                 this.logDebugPayload('Feishu', payload);
+                const question = this.questionCardController.claim(payload);
+                if (question.kind === 'handled') {
+                    const execute = question.execute;
+                    if (execute) {
+                        setImmediate(() => {
+                            execute().catch((error) => {
+                                process.stderr.write(`[Feishu:${this.name}] question action execution error: ${error instanceof Error ? error.message : error}\n`);
+                            });
+                        });
+                    }
+                    return question.response;
+                }
                 const stopped = this.onCardAction(payload);
                 if (stopped) {
                     return { toast: { type: 'info', content: '已停止' } };
@@ -443,10 +494,12 @@ export class FeishuChannel extends ChannelBase {
         text = text.replace(/^好的，<at[^>]*><\/at>\s*\n*/, '');
         return text.trim() || undefined;
     }
-    async getTenantAccessToken() {
+    async getTenantAccessToken(options) {
         if (this.tokenCache && Date.now() < this.tokenCache.expiresAt) {
             return this.tokenCache.token;
         }
+        if (!options?.silent)
+            this.tokenRefreshHasCoreWaiters = true;
         if (this.tokenRefreshPromise)
             return this.tokenRefreshPromise;
         this.tokenRefreshPromise = this.refreshToken();
@@ -455,9 +508,12 @@ export class FeishuChannel extends ChannelBase {
         }
         finally {
             this.tokenRefreshPromise = undefined;
+            this.tokenRefreshHasCoreWaiters = false;
         }
     }
     async refreshToken() {
+        // Best-effort label enrichment initiates silent refreshes; failures must
+        // still surface when a core delivery caller initiated or joined it.
         try {
             const resp = await fetch(`${BASE_URL}/auth/v3/tenant_access_token/internal`, {
                 method: 'POST',
@@ -469,7 +525,9 @@ export class FeishuChannel extends ChannelBase {
                 signal: AbortSignal.timeout(15_000),
             });
             if (!resp.ok) {
-                process.stderr.write(`[Feishu:${this.name}] getTenantAccessToken failed: HTTP ${resp.status}\n`);
+                if (this.tokenRefreshHasCoreWaiters) {
+                    process.stderr.write(`[Feishu:${this.name}] getTenantAccessToken failed: HTTP ${resp.status}\n`);
+                }
                 if (resp.status === 401)
                     this.tokenCache = undefined;
                 return undefined;
@@ -483,10 +541,187 @@ export class FeishuChannel extends ChannelBase {
             return this.tokenCache.token;
         }
         catch (err) {
-            process.stderr.write(`[Feishu:${this.name}] getTenantAccessToken error: ${err}\n`);
+            if (this.tokenRefreshHasCoreWaiters) {
+                process.stderr.write(`[Feishu:${this.name}] getTenantAccessToken error: ${err}\n`);
+            }
             return undefined;
         }
     }
+    hydrateObservedNames() {
+        if (this.hydratedObservedNames)
+            return;
+        this.hydratedObservedNames = true;
+        const graph = this.persistedObservedContacts();
+        if (!graph)
+            return;
+        // Select the newest non-ID label per contact so an older observation
+        // (for example a stale group membership) cannot overwrite a more recent
+        // one during the traversal.
+        const newestUser = new Map();
+        const newestChat = new Map();
+        const consider = (best, id, label, at) => {
+            if (label === id)
+                return;
+            const current = best.get(id);
+            if (!current || at >= current.at)
+                best.set(id, { label, at });
+        };
+        for (const user of graph.users) {
+            consider(newestUser, user.id, user.label, user.lastObservedAt);
+        }
+        for (const group of graph.groups) {
+            consider(newestChat, group.id, group.label, group.lastObservedAt);
+            for (const member of group.users) {
+                consider(newestUser, member.id, member.label, member.lastObservedAt);
+            }
+        }
+        for (const [id, entry] of newestUser) {
+            this.observedUserNames.set(id, entry.label);
+        }
+        for (const [id, entry] of newestChat) {
+            this.observedChatNames.set(id, entry.label);
+        }
+        this.capObservedCache(this.observedUserNames);
+        this.capObservedCache(this.observedChatNames);
+    }
+    /** Evicts the oldest-inserted entries once a runtime cache exceeds the cap. */
+    capObservedCache(cache) {
+        let evicted = false;
+        while (cache.size > OBSERVED_LABEL_CACHE_LIMIT) {
+            const oldest = cache.keys().next();
+            if (oldest.done)
+                break;
+            cache.delete(oldest.value);
+            evicted = true;
+        }
+        return evicted;
+    }
+    observedUserName(userId) {
+        const userIdType = userId.startsWith('ou_')
+            ? 'open_id'
+            : userId.startsWith('on_')
+                ? 'union_id'
+                : 'user_id';
+        return this.observedNameLookup({
+            lookups: this.observedUserLookups,
+            names: this.observedUserNames,
+            id: userId,
+            request: (token) => fetch(`${BASE_URL}/contact/v3/users/basic_batch?user_id_type=${userIdType}`, {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${token}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({ user_ids: [userId] }),
+                signal: AbortSignal.timeout(15_000),
+            }),
+            extractName: (body) => {
+                const data = body;
+                return data.code === 0 ? data.data?.users?.[0]?.name : undefined;
+            },
+        });
+    }
+    observedChatName(chatId) {
+        return this.observedNameLookup({
+            lookups: this.observedChatLookups,
+            names: this.observedChatNames,
+            id: chatId,
+            request: (token) => fetch(`${BASE_URL}/im/v1/chats/${encodeURIComponent(chatId)}`, {
+                headers: { Authorization: `Bearer ${token}` },
+                signal: AbortSignal.timeout(15_000),
+            }),
+            extractName: (body) => {
+                const data = body;
+                return data.code === 0 ? data.data?.name : undefined;
+            },
+        });
+    }
+    observedNameLookup(options) {
+        const cached = options.names.get(options.id);
+        if (cached)
+            return Promise.resolve(cached);
+        const existing = options.lookups.get(options.id);
+        if (existing)
+            return existing;
+        const lookup = (async () => {
+            try {
+                const token = await this.getTenantAccessToken({ silent: true });
+                if (!token) {
+                    options.lookups.delete(options.id);
+                    return undefined;
+                }
+                const response = await options.request(token);
+                if (!response.ok) {
+                    if (response.status === 401) {
+                        this.tokenCache = undefined;
+                        options.lookups.delete(options.id);
+                    }
+                    return undefined;
+                }
+                const name = options.extractName(await response.json())?.trim();
+                if (!name)
+                    return undefined;
+                const label = sanitizeSenderName(name);
+                if (label === 'unknown')
+                    return undefined;
+                options.names.set(options.id, label);
+                // Evicting a resolved label drops the next envelope back to the raw
+                // ID, and the initial persistence write would clobber the persisted
+                // label, so re-hydrate from the registry on the next message.
+                if (this.capObservedCache(options.names)) {
+                    this.hydratedObservedNames = false;
+                }
+                return label;
+            }
+            catch {
+                return undefined;
+            }
+        })();
+        options.lookups.set(options.id, lookup);
+        this.capObservedCache(options.lookups);
+        return lookup;
+    }
+    onObservedContact(envelope) {
+        this.observedContactWrites.set(this.observedContactKey(envelope), {
+            senderName: envelope.senderName,
+            chatName: envelope.chatName,
+        });
+        this.capObservedCache(this.observedContactWrites);
+        void this.enrichObservedContact(envelope).catch(() => { });
+    }
+    observedContactKey(envelope) {
+        return envelope.isGroup
+            ? `${envelope.senderId}\u0000${envelope.chatId}\u0000${envelope.threadId ?? ''}`
+            : envelope.senderId;
+    }
+    async enrichObservedContact(envelope) {
+        const [senderName, chatName] = await Promise.all([
+            this.observedUserName(envelope.senderId),
+            envelope.isGroup
+                ? this.observedChatName(envelope.chatId)
+                : Promise.resolve(undefined),
+        ]);
+        if (!senderName && !chatName)
+            return;
+        const key = this.observedContactKey(envelope);
+        const nextLabels = {
+            senderName: senderName ?? envelope.senderName,
+            chatName: chatName ?? envelope.chatName,
+        };
+        const persistedLabels = this.observedContactWrites.get(key);
+        if (persistedLabels &&
+            persistedLabels.senderName === nextLabels.senderName &&
+            persistedLabels.chatName === nextLabels.chatName) {
+            return;
+        }
+        this.observedContactWrites.set(key, nextLabels);
+        this.capObservedCache(this.observedContactWrites);
+        await this.recordObservedContact({
+            ...envelope,
+            ...(senderName ? { senderName } : {}),
+            ...(chatName ? { chatName } : {}),
+        });
+    }
     async sendMessage(chatId, text) {
         await this.sendMessageInternal(chatId, text, false);
     }
@@ -561,54 +796,92 @@ export class FeishuChannel extends ChannelBase {
         }
     }
     // ----- Interactive Card Streaming -----
-    async createStreamingCard(chatId, text, title, inboundMsgId) {
+    async sendInteractiveCard(chatId, card) {
         const token = await this.getTenantAccessToken();
         if (!token)
-            return { messageId: '', success: false };
-        const cardTitle = title || (inboundMsgId && this.msgToQuestion.get(inboundMsgId)) || 'Qwen';
-        const card = buildCardContent(text, {
-            title: cardTitle,
-            showStopButton: true,
-            isStreaming: true,
-            statusLabel: this.statusLabelFor(),
-            collapsible: this.collapsible,
-            collapsibleThreshold: this.collapsibleThreshold,
+            throw new FeishuCardDeliveryError('Feishu card delivery failed: no access token');
+        const resp = await fetch(`${BASE_URL}/im/v1/messages?receive_id_type=chat_id`, {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${token}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                receive_id: chatId,
+                msg_type: 'interactive',
+                content: JSON.stringify(card),
+            }),
+            signal: AbortSignal.timeout(15_000),
         });
-        const body = {
-            receive_id: chatId,
-            msg_type: 'interactive',
-            content: JSON.stringify(card),
-        };
+        if (!resp.ok) {
+            if (resp.status === 401)
+                this.tokenCache = undefined;
+            const detail = await resp.text().catch(() => '');
+            const errorDetail = `HTTP ${resp.status} ${detail}`;
+            throw new FeishuCardDeliveryError(`Feishu card delivery failed: ${errorDetail}`, errorDetail);
+        }
+        const data = (await resp.json());
+        const messageId = data.data?.message_id;
+        if (!messageId) {
+            throw new FeishuCardDeliveryError('Feishu card delivery returned no message id');
+        }
+        return messageId;
+    }
+    async patchInteractiveCard(messageId, card) {
+        const token = await this.getTenantAccessToken();
+        if (!token || !FEISHU_ID_RE.test(messageId))
+            return false;
         try {
-            const resp = await fetch(`${BASE_URL}/im/v1/messages?receive_id_type=chat_id`, {
-                method: 'POST',
+            const resp = await fetch(`${BASE_URL}/im/v1/messages/${messageId}`, {
+                method: 'PATCH',
                 headers: {
                     Authorization: `Bearer ${token}`,
                     'Content-Type': 'application/json',
                 },
-                body: JSON.stringify(body),
+                body: JSON.stringify({
+                    msg_type: 'interactive',
+                    content: JSON.stringify(card),
+                }),
                 signal: AbortSignal.timeout(15_000),
             });
             if (!resp.ok) {
                 if (resp.status === 401)
                     this.tokenCache = undefined;
                 const detail = await resp.text().catch(() => '');
-                process.stderr.write(`[Feishu:${this.name}] createStreamingCard failed: HTTP ${resp.status} ${detail}\n`);
-                return { messageId: '', success: false };
+                process.stderr.write(`[Feishu:${this.name}] updateCard failed: HTTP ${resp.status} ${detail}\n`);
+                return false;
             }
-            const data = (await resp.json());
-            const messageId = data.data?.message_id || '';
-            return { messageId, success: !!messageId };
+            return true;
         }
         catch (err) {
+            process.stderr.write(`[Feishu:${this.name}] updateCard error: ${err}\n`);
+            return false;
+        }
+    }
+    async createStreamingCard(chatId, text, title, inboundMsgId) {
+        const cardTitle = title || (inboundMsgId && this.msgToQuestion.get(inboundMsgId)) || 'Qwen';
+        const card = buildCardContent(text, {
+            title: cardTitle,
+            showStopButton: true,
+            isStreaming: true,
+            statusLabel: this.statusLabelFor(),
+            collapsible: this.collapsible,
+            collapsibleThreshold: this.collapsibleThreshold,
+        });
+        try {
+            const messageId = await this.sendInteractiveCard(chatId, card);
+            return { messageId, success: true };
+        }
+        catch (err) {
+            if (err instanceof FeishuCardDeliveryError) {
+                process.stderr.write(`[Feishu:${this.name}] createStreamingCard failed: ${err.detail ?? err.message}\n`);
+                return { messageId: '', success: false };
+            }
             process.stderr.write(`[Feishu:${this.name}] createStreamingCard error: ${err}\n`);
             return { messageId: '', success: false };
         }
     }
     async updateCard(messageId, text, finished = false, inboundMsgId, statusLabel) {
-        const token = await this.getTenantAccessToken();
-        if (!token)
-            return false;
         const cardTitle = inboundMsgId
             ? this.msgToQuestion.get(inboundMsgId) || 'Qwen'
             : 'Qwen';
@@ -620,34 +893,22 @@ export class FeishuChannel extends ChannelBase {
             collapsible: this.collapsible,
             collapsibleThreshold: this.collapsibleThreshold,
         });
-        if (!FEISHU_ID_RE.test(messageId))
-            return false;
-        try {
-            const resp = await fetch(`${BASE_URL}/im/v1/messages/${messageId}`, {
-                method: 'PATCH',
-                headers: {
-                    Authorization: `Bearer ${token}`,
-                    'Content-Type': 'application/json',
-                },
-                body: JSON.stringify({
-                    msg_type: 'interactive',
-                    content: JSON.stringify(card),
-                }),
-                signal: AbortSignal.timeout(15_000),
-            });
-            if (!resp.ok) {
-                if (resp.status === 401)
-                    this.tokenCache = undefined;
-                const detail = await resp.text().catch(() => '');
-                process.stderr.write(`[Feishu:${this.name}] updateCard failed: HTTP ${resp.status} ${detail}\n`);
-                return false;
+        return this.patchInteractiveCard(messageId, card);
+    }
+    async presentUserInputRequest(context) {
+        if (!context.precedingSegmentId) {
+            const inboundMsgId = this.sessionToInboundMsg.get(context.sessionId);
+            const cardState = inboundMsgId
+                ? this.cardSessions.get(inboundMsgId)
+                : undefined;
+            if (inboundMsgId && cardState) {
+                // Production bridges emit response_boundary synchronously before the
+                // permission request, so the segment is already closed and no
+                // input_requested segment end runs — end the output presentation here.
+                await this.endOutputCardBeforeInputRequest(context.target.chatId, inboundMsgId, cardState);
             }
-            return true;
-        }
-        catch (err) {
-            process.stderr.write(`[Feishu:${this.name}] updateCard error: ${err}\n`);
-            return false;
         }
+        return this.questionCardController.present(context);
     }
     /** Delete a card message from Feishu to prevent orphaned "思考中..." cards. */
     async deleteCard(messageId) {
@@ -702,6 +963,7 @@ export class FeishuChannel extends ChannelBase {
         }
         if (cardState.stopped)
             return;
+        cardState.boundaryText = undefined;
         const MAX_ACCUMULATE = 25_000;
         cardState.accumulatedText += chunk;
         if (cardState.accumulatedText.length > MAX_ACCUMULATE) {
@@ -714,12 +976,19 @@ export class FeishuChannel extends ChannelBase {
         // If card not yet created (fallback path), create now
         if (!cardState.created && !cardState.cardCreationFailed) {
             cardState.creating = true;
+            // The orphan sweep times out creations by lastUpdateAt; anchor it at
+            // creation start so a stale released pre-question entry cannot trip
+            // the 60s bound mid-creation.
+            cardState.lastUpdateAt = Date.now();
             const cs = cardState;
             cardState.creationTimer = setTimeout(async () => {
                 try {
                     if (cs.stopped || this.stoppedMessages.has(inboundMsgId)) {
                         cs.creating = false;
-                        this.cleanupCard(inboundMsgId);
+                        // An abandoned stop belongs to a pending-question release that
+                        // intentionally kept the auxiliary maps — cleanup would wipe them.
+                        if (!cs.abandoned)
+                            this.cleanupCard(inboundMsgId);
                         return;
                     }
                     // Note: don't check cancelling here — let the card creation proceed.
@@ -772,39 +1041,53 @@ export class FeishuChannel extends ChannelBase {
             const cs = cardState;
             const elapsed = Date.now() - cardState.lastUpdateAt;
             const delay = Math.max(0, CARD_UPDATE_INTERVAL_MS - elapsed);
-            cardState.pendingUpdateTimer = setTimeout(async () => {
+            cardState.pendingUpdateTimer = setTimeout(() => {
                 cs.pendingUpdateTimer = undefined;
                 if (cs.stopped || cs.finalizing)
                     return;
                 cs.lastUpdateAt = Date.now();
-                try {
-                    const MAX_CARD_CHARS = 20_000;
-                    const atPrefix = this.msgToSenderName.get(inboundMsgId);
-                    let displayContent = atPrefix
-                        ? `${atPrefix}\n\n${cs.accumulatedText}`
-                        : cs.accumulatedText;
-                    if (displayContent.length > MAX_CARD_CHARS) {
-                        const marker = '\n\n_(内容过长，已截断早期内容)_';
-                        displayContent =
-                            displayContent.slice(-(MAX_CARD_CHARS - marker.length)) + marker;
-                        // Re-balance code fences after truncation
-                        if (this.countFences(displayContent) % 2 === 1) {
-                            displayContent = '```\n' + displayContent;
-                        }
-                    }
-                    const ok = await this.updateCard(cs.messageId, displayContent, false, inboundMsgId);
-                    if (!ok) {
-                        // Fallback: strip tables to avoid card table limit (code-fence aware)
-                        const stripped = this.stripTables(displayContent, '(表格)');
-                        await this.updateCard(cs.messageId, stripped, false, inboundMsgId);
-                    }
+                if (cs.pendingUpdatePromise) {
+                    // A run is already in flight or queued — coalesce instead of
+                    // stacking a burst of PATCHes; the trailing run picks up the
+                    // latest accumulated buffer.
+                    cs.updateQueued = true;
+                    return;
                 }
-                catch (err) {
+                cs.pendingUpdatePromise = this.runThrottledCardUpdate(inboundMsgId, cs)
+                    .catch((err) => {
                     process.stderr.write(`[Feishu:${this.name}] card update error: ${err}\n`);
-                }
+                })
+                    .then(() => {
+                    cs.pendingUpdatePromise = undefined;
+                });
             }, delay);
         }
     }
+    /** Runs one throttled streaming PATCH, then re-runs once when timer fires
+     *  coalesced behind it (`updateQueued`) so the latest buffer still goes out.
+     *  `pendingUpdatePromise` covers the whole chain so finalization can drain
+     *  every in-flight update before sending the final patch. */
+    async runThrottledCardUpdate(inboundMsgId, cs) {
+        if (cs.stopped || cs.finalizing)
+            return;
+        try {
+            const atPrefix = this.msgToSenderName.get(inboundMsgId);
+            const displayContent = this.truncateCardText(atPrefix ? `${atPrefix}\n\n${cs.accumulatedText}` : cs.accumulatedText);
+            const ok = await this.updateCard(cs.messageId, displayContent, false, inboundMsgId);
+            if (!ok && !cs.stopped && !cs.finalizing) {
+                // Fallback: strip tables to avoid card table limit (code-fence aware)
+                const stripped = this.stripTables(displayContent, '(表格)');
+                await this.updateCard(cs.messageId, stripped, false, inboundMsgId);
+            }
+        }
+        catch (err) {
+            process.stderr.write(`[Feishu:${this.name}] card update error: ${err}\n`);
+        }
+        if (cs.updateQueued) {
+            cs.updateQueued = false;
+            await this.runThrottledCardUpdate(inboundMsgId, cs);
+        }
+    }
     onResponseBoundary(_chatId, sessionId) {
         if (this.config.blockStreaming === 'on')
             return;
@@ -818,8 +1101,112 @@ export class FeishuChannel extends ChannelBase {
             clearTimeout(cardState.pendingUpdateTimer);
             cardState.pendingUpdateTimer = undefined;
         }
+        // The boundary empties the buffer, so a coalesced trailing run would have
+        // nothing legitimate to send; drop the flag or it PATCHes the card empty.
+        cardState.updateQueued = false;
+        if (cardState.accumulatedText) {
+            cardState.boundaryText = cardState.accumulatedText;
+        }
         cardState.accumulatedText = '';
     }
+    async onOutputSegmentEnd(chatId, sessionId, _segment, reason) {
+        if (reason === 'response_boundary') {
+            this.onResponseBoundary(chatId, sessionId);
+            return;
+        }
+        if (reason !== 'input_requested' || this.config.blockStreaming === 'on') {
+            return;
+        }
+        const inboundMsgId = this.sessionToInboundMsg.get(sessionId);
+        if (!inboundMsgId)
+            return;
+        const cardState = this.cardSessions.get(inboundMsgId);
+        if (!cardState)
+            return;
+        await this.endOutputCardBeforeInputRequest(chatId, inboundMsgId, cardState);
+    }
+    async endOutputCardBeforeInputRequest(chatId, inboundMsgId, cardState) {
+        // Stop owns the card once the user clicks it: handleStop refuses to race
+        // a finalizing card, so finalizing here would render 已完成 over a stopped
+        // run and drop the stop label. Leave the card to the stop wind-down paths.
+        if (cardState.cancelling ||
+            cardState.stopped ||
+            cardState.finalizing ||
+            this.stoppedMessages.has(inboundMsgId)) {
+            return;
+        }
+        const atPrefix = this.msgToSenderName.get(inboundMsgId);
+        const text = cardState.accumulatedText || cardState.boundaryText || '';
+        const displayText = atPrefix
+            ? text
+                ? `${atPrefix}\n\n${text}`
+                : atPrefix
+            : text;
+        // Mirror onResponseComplete: reserve room for the greeting prefix and the
+        // completed status block that buildCardContent renders alongside the text.
+        const completedSuffix = `\n\n---\n*${this.statusLabelFor('completed')}*`;
+        const prefixPart = atPrefix && text ? `${atPrefix}\n\n` : '';
+        const finalText = text
+            ? prefixPart +
+                this.truncateCardText(text, prefixPart.length + completedSuffix.length)
+            : displayText;
+        try {
+            if (cardState.created && cardState.messageId && !cardState.stopped) {
+                // Mirror onResponseComplete: block the throttled update path before
+                // the final patch. Clearing a timer that already fired is a no-op, so
+                // an in-flight streaming PATCH is awaited as well — otherwise it can
+                // land after the final patch and re-render the card as running.
+                cardState.finalizing = true;
+                if (cardState.pendingUpdateTimer) {
+                    clearTimeout(cardState.pendingUpdateTimer);
+                    cardState.pendingUpdateTimer = undefined;
+                }
+                if (cardState.pendingUpdatePromise) {
+                    await cardState.pendingUpdatePromise;
+                }
+                let updated = false;
+                try {
+                    // Stop may settle during the drain above; mirror onResponseComplete
+                    // and hand the card to the stop path instead of labelling a stopped
+                    // run 已完成.
+                    if (await this.finalizeStoppedCardUpdate(inboundMsgId, cardState, chatId)) {
+                        return;
+                    }
+                    updated = await this.updateCard(cardState.messageId, finalText, true, inboundMsgId, this.statusLabelFor('completed'));
+                    if (!updated) {
+                        // Mirror onResponseComplete: retry without tables (Feishu card
+                        // table-count limit) before giving up on the card.
+                        const noTableText = this.stripTables(finalText, '(表格内容请查看原文)');
+                        updated = await this.updateCard(cardState.messageId, noTableText, true, inboundMsgId, this.statusLabelFor('completed'));
+                    }
+                    // Stop may also settle during the patch awaits above.
+                    if (await this.finalizeStoppedCardUpdate(inboundMsgId, cardState, chatId)) {
+                        return;
+                    }
+                }
+                catch (error) {
+                    process.stderr.write(`[Feishu:${this.name}] input-request card finalization error: ${error instanceof Error ? error.message : error}\n`);
+                }
+                if (!updated) {
+                    await this.deleteCard(cardState.messageId);
+                    if (displayText)
+                        await this.sendMessage(chatId, displayText);
+                }
+            }
+            else {
+                if (cardState.creating) {
+                    cardState.stopped = true;
+                    cardState.abandoned = true;
+                }
+                if (text) {
+                    await this.sendMessage(chatId, displayText);
+                }
+            }
+        }
+        finally {
+            this.releaseOutputCard(inboundMsgId);
+        }
+    }
     isKnownInboundMessageId(messageId) {
         return (this.msgToQuestion.has(messageId) ||
             this.msgToSenderName.has(messageId) ||
@@ -871,6 +1258,14 @@ export class FeishuChannel extends ChannelBase {
         if (!isTerminalTaskLifecycleType(event.type)) {
             return;
         }
+        if (event.runId) {
+            // Mirror the DingTalk sibling: only a user-initiated cancel projects
+            // 已取消; a completed or failed run leaves the question 已过期.
+            this.questionCardController.cancelRun(event.runId, event.type === 'cancelled' &&
+                (event.reason === 'cancel_command' || event.reason === 'clear')
+                ? 'cancelled'
+                : 'expired');
+        }
         const inboundMsgId = this.knownInboundMessageId(event.sessionId, event.messageId);
         if (!inboundMsgId)
             return;
@@ -899,34 +1294,23 @@ export class FeishuChannel extends ChannelBase {
         }
         // Prepend greeting with sender name
         const atSender = this.msgToSenderName.get(inboundMsgId);
-        let displayText = atSender ? `${atSender}\n\n${fullText}` : fullText;
         const completedLabel = this.statusLabelFor('completed');
         const completedSuffix = `\n\n---\n*${completedLabel}*`;
-        // Enforce card size limit to avoid wasted API round-trips
-        const MAX_FINAL_CARD_CHARS = 20_000;
-        if (displayText.length + completedSuffix.length > MAX_FINAL_CARD_CHARS) {
-            const prefix = atSender ? `${atSender}\n\n` : '';
-            const suffix = '\n\n_(内容过长，已截断早期内容)_';
-            const fenceReserve = 4; // potential '```\n' prepend for fence rebalancing
-            const maxBody = MAX_FINAL_CARD_CHARS -
-                prefix.length -
-                suffix.length -
-                completedSuffix.length -
-                fenceReserve;
-            displayText = prefix + fullText.slice(-maxBody) + suffix;
-            // Re-balance code fences after truncation (line-by-line, handles indented fences)
-            if (this.countFences(displayText) % 2 === 1) {
-                displayText = '```\n' + displayText;
-            }
-        }
+        const atPrefix = atSender ? `${atSender}\n\n` : '';
+        // Enforce card size limit to avoid wasted API round-trips; reserve room
+        // for the greeting prefix and the completed status block.
+        const displayText = atPrefix +
+            this.truncateCardText(fullText, atPrefix.length + completedSuffix.length);
         // Mark as finalizing to prevent concurrent updates/create from timers
         if (cardState)
             cardState.finalizing = true;
         if (cardState?.pendingUpdateTimer) {
             clearTimeout(cardState.pendingUpdateTimer);
         }
-        if (cardState?.creationTimer) {
-            clearTimeout(cardState.creationTimer);
+        // Do not clear creationTimer: the pending creation callback is the only
+        // path that clears `creating`, which the busy-wait below drains.
+        if (cardState?.pendingUpdatePromise) {
+            await cardState.pendingUpdatePromise;
         }
         // Wait for in-flight card creation (with 10s timeout)
         if (cardState?.creating) {
@@ -1009,73 +1393,22 @@ export class FeishuChannel extends ChannelBase {
         this.cleanupCard(inboundMsgId);
         await this.sendMessage(chatId, atSender ? `${atSender}\n\n${fullText}` : fullText);
     }
-    onPromptStart(chatId, sessionId, messageId) {
+    onPromptStart(_chatId, sessionId, messageId) {
         const inboundMsgId = messageId && this.isKnownInboundMessageId(messageId)
             ? messageId
             : undefined;
         if (inboundMsgId) {
             this.sessionToInboundMsg.set(sessionId, inboundMsgId);
             this.addReaction(inboundMsgId, 'OnIt').catch(() => { });
-            // In blockStreaming mode, skip card creation — BlockStreamer handles delivery
-            if (this.config.blockStreaming === 'on')
-                return;
-            // Create streaming card now that gating has passed
-            if (!this.cardSessions.has(inboundMsgId)) {
-                const atSender = this.msgToSenderName.get(inboundMsgId) || '';
-                const placeholderText = atSender
-                    ? `${atSender}，思考中...`
-                    : '思考中...';
-                const cardState = {
+            if (this.config.blockStreaming !== 'on' &&
+                !this.cardSessions.has(inboundMsgId)) {
+                this.cardSessions.set(inboundMsgId, {
                     messageId: '',
                     created: false,
-                    creating: true,
+                    creating: false,
                     stopped: false,
                     accumulatedText: '',
                     lastUpdateAt: Date.now(),
-                };
-                this.cardSessions.set(inboundMsgId, cardState);
-                this.createStreamingCard(chatId, placeholderText, undefined, inboundMsgId)
-                    .then((result) => {
-                    // Only check stopped (not cancelling) — cancelling is set before
-                    // cancelSession resolves, and the card must still be created so
-                    // handleStop can update it once cancelSession completes.
-                    if (cardState.stopped || this.stoppedMessages.has(inboundMsgId)) {
-                        // If abandoned by busy-wait timeout, delete the streaming card —
-                        // the response was already delivered via sendMessage.
-                        if (cardState.abandoned) {
-                            if (result.success) {
-                                this.deleteCard(result.messageId).catch((err) => {
-                                    process.stderr.write(`[Feishu:${this.name}] ORPHANED CARD: failed to delete abandoned card msg=${result.messageId}: ${err instanceof Error ? err.message : err}\n`);
-                                });
-                            }
-                            cardState.creating = false;
-                            return;
-                        }
-                        if (result.success) {
-                            // Use cardState.atPrefix (captured by onCardAction before cleanupCard)
-                            const prefix = cardState.atPrefix ||
-                                this.msgToSenderName.get(inboundMsgId) ||
-                                '';
-                            this.updateCard(result.messageId, prefix, true, inboundMsgId, this.stopLabelFor(cardState.terminalStatus, cardState.userStopped ?? false)).catch(() => { });
-                        }
-                        cardState.creating = false;
-                        this.cleanupCard(inboundMsgId);
-                        return;
-                    }
-                    if (result.success) {
-                        cardState.messageId = result.messageId;
-                        cardState.created = true;
-                        cardState.lastUpdateAt = Date.now();
-                    }
-                    else {
-                        cardState.cardCreationFailed = true;
-                    }
-                    cardState.creating = false;
-                })
-                    .catch((err) => {
-                    process.stderr.write(`[Feishu:${this.name}] Processing card error: ${err}\n`);
-                    cardState.creating = false;
-                    this.cleanupCard(inboundMsgId);
                 });
             }
         }
@@ -1096,6 +1429,16 @@ export class FeishuChannel extends ChannelBase {
                 }
                 else if (cs.created) {
                     cs.stopped = true;
+                    // Mirror the other final-patch paths: drain the streaming chain so
+                    // the terminal patch is the last update Feishu applies.
+                    cs.finalizing = true;
+                    if (cs.pendingUpdateTimer) {
+                        clearTimeout(cs.pendingUpdateTimer);
+                        cs.pendingUpdateTimer = undefined;
+                    }
+                    if (cs.pendingUpdatePromise) {
+                        await cs.pendingUpdatePromise;
+                    }
                     const atPrefix = this.msgToSenderName.get(inboundMsgId) || '';
                     const terminalStatus = cs.terminalStatus ?? (cs.cancelling ? 'cancelled' : 'failed');
                     // userStopped: a Stop click may lose the race against this wind-down
@@ -1120,9 +1463,10 @@ export class FeishuChannel extends ChannelBase {
                             : cs.accumulatedText;
                         this.sendMessage(_chatId, fallbackText).catch(() => { });
                     }
-                    else {
-                        // No accumulated text (e.g. immediate LLM error before first chunk)
-                        // — send a generic error so the user isn't left without feedback.
+                    else if (cs.terminalStatus !== 'completed') {
+                        // No accumulated text (e.g. a failure before the first chunk, or a
+                        // post-answer failure after the output card was released for a
+                        // question). A completed turn with no output ends silently.
                         const atPrefix = this.msgToSenderName.get(inboundMsgId) || '';
                         const fallbackLabel = cs.terminalStatus
                             ? this.statusLabelFor(cs.terminalStatus)
@@ -1289,6 +1633,16 @@ export class FeishuChannel extends ChannelBase {
                 // If onResponseComplete is already finalizing the card, don't race with it.
                 if (cardState.finalizing)
                     return;
+                // Mirror the other final-patch paths: drain the streaming chain so a
+                // slow or reordered streaming PATCH cannot land after the stop patch
+                // and re-render the stopped card as running.
+                if (cardState.pendingUpdateTimer) {
+                    clearTimeout(cardState.pendingUpdateTimer);
+                    cardState.pendingUpdateTimer = undefined;
+                }
+                if (cardState.pendingUpdatePromise) {
+                    await cardState.pendingUpdatePromise;
+                }
                 // Only update card if it was actually created (skip if still creating —
                 // the createStreamingCard callback will finalize using cardState.atPrefix)
                 if (cardState.created && cardState.messageId) {
@@ -1331,6 +1685,7 @@ export class FeishuChannel extends ChannelBase {
         }
     }
     disconnect() {
+        this.questionCardController.dispose();
         if (this.dedupTimer) {
             clearInterval(this.dedupTimer);
             this.dedupTimer = undefined;
@@ -1406,6 +1761,22 @@ export class FeishuChannel extends ChannelBase {
         }
         return result.join('\n');
     }
+    /** Truncate card content to the Feishu card size limit, keeping the tail.
+     *  `reservedChars` covers content rendered alongside the text (greeting
+     *  prefix, status block) that must fit the same limit. */
+    truncateCardText(text, reservedChars = 0) {
+        const MAX_CARD_CHARS = 20_000;
+        if (text.length + reservedChars <= MAX_CARD_CHARS)
+            return text;
+        const marker = '\n\n_(内容过长，已截断早期内容)_';
+        const fenceReserve = 4; // potential '```\n' prepend for fence rebalancing
+        let truncated = text.slice(-(MAX_CARD_CHARS - marker.length - fenceReserve - reservedChars)) + marker;
+        // Re-balance code fences after truncation
+        if (this.countFences(truncated) % 2 === 1) {
+            truncated = '```\n' + truncated;
+        }
+        return truncated;
+    }
     cleanupCard(inboundMsgId) {
         const cardState = this.cardSessions.get(inboundMsgId);
         if (cardState?.pendingUpdateTimer) {
@@ -1427,6 +1798,33 @@ export class FeishuChannel extends ChannelBase {
             }
         }
     }
+    releaseOutputCard(inboundMsgId) {
+        const cardState = this.cardSessions.get(inboundMsgId);
+        if (!cardState)
+            return;
+        if (cardState.pendingUpdateTimer) {
+            clearTimeout(cardState.pendingUpdateTimer);
+        }
+        if (cardState.creationTimer) {
+            clearTimeout(cardState.creationTimer);
+        }
+        // Keep an inert entry while the question is pending: the orphan sweep and
+        // the terminal-feedback paths both key on card-session presence. Carry any
+        // terminal status onTaskLifecycle wrote during the awaited finalization.
+        this.cardSessions.set(inboundMsgId, {
+            messageId: '',
+            created: false,
+            creating: false,
+            // Carry a settled user stop (not the abandoned-creation marker) so a
+            // late-settled stop cannot flip onPromptEnd into a contradictory
+            // terminal message.
+            stopped: cardState.stopped && !cardState.abandoned,
+            accumulatedText: '',
+            lastUpdateAt: Date.now(),
+            userStopped: cardState.userStopped,
+            terminalStatus: cardState.terminalStatus,
+        });
+    }
     // ----- Message handling -----
     onMessage(data) {
         try {
@@ -1446,6 +1844,9 @@ export class FeishuChannel extends ChannelBase {
                 sender.sender_id?.user_id ||
                 sender.sender_id?.union_id ||
                 '';
+            this.hydrateObservedNames();
+            const senderName = this.observedUserNames.get(senderId) || senderId;
+            const chatName = isGroup ? this.observedChatNames.get(chatId) : undefined;
             // Parse message content
             const content = this.extractContent(msg.message_type, msg.content);
             // Check @mention
@@ -1481,8 +1882,9 @@ export class FeishuChannel extends ChannelBase {
             const envelope = {
                 channelName: this.name,
                 senderId,
-                senderName: senderId,
+                senderName,
                 chatId,
+                ...(chatName ? { chatName } : {}),
                 text: cleanText,
                 messageId: msgId,
                 threadId: msg.root_id || undefined,