@kafca/agentdock 0.1.19 → 0.1.21

package/dist-electron/services/local-ai-core/src/gateway/local-core-lark-gateway.js

@@ -40,9 +40,9 @@ const desktop_js_1 = require("../../../../shared/desktop.js");
 const PAIRING_EXPIRY_MS = 10 * 60 * 1000;
 class LocalCoreLarkGateway extends node_events_1.EventEmitter {
     options;
-    // Lark card action callbacks are unreliable in current WS-only setup (code 200340).
-    // Keep permission approval on explicit text commands: allow all / allow / deny.
-    enableCardActions = false;
+    // Lark returns 200340 when card action events are not enabled in the app's
+    // event subscription. Keep card actions opt-in so text approval always works.
+    defaultCardActionsEnabled = false;
     // Keep permission state in a dedicated card to avoid mixing order in the main reply card.
     mirrorPermissionStateInMainCard = false;
     runtime = new Map();
@@ -79,6 +79,7 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
                         status: 'disabled',
                         connected: false,
                         appId: binding.appId,
+                        cardActionsEnabled: binding.cardActionsEnabled,
                     });
                 }
                 continue;
@@ -272,7 +273,7 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
                     this.options.store.clearPlatformThreadMessageId(route.workspaceId, route.chatId, route.platformUserId);
                 }
                 if (event.type === 'buttons') {
-                    const permissionCard = this.renderPermissionCard(turn, event);
+                    const permissionCard = this.renderPermissionCard(turn, event, Boolean(state.cardActionsEnabled));
                     if (permissionCard.text || permissionCard.buttonRows.length > 0) {
                         if (!turn.permissionMessageId) {
                             const createdId = await this.sendTextAsCard(state, route.chatId, permissionCard.text, permissionCard.buttonRows, sessionKey, binding.thread_id);
@@ -290,30 +291,35 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
                     return;
                 }
                 this.consumeBridgeEvent(turn, event);
-                const rendered = this.renderTurnCard(turn);
+                const rendered = this.renderBridgeEventMessage(turn, event);
                 if (!rendered.text && rendered.buttonRows.length === 0) {
                     this.options.log?.(`localcore-lark bridge event produced empty render for sessionKey=${sessionKey} type=${event.type}`);
                     return;
                 }
+                const existingMessageId = this.getRenderedMessageId(turn, rendered);
                 const shouldThrottle = event.type === 'update_message' &&
-                    turn.messageId &&
-                    Date.now() - turn.lastPatchedAt < 900;
-                this.options.log?.(`localcore-lark bridge event type=${event.type} sessionKey=${sessionKey} hasMessageId=${Boolean(turn.messageId)} throttle=${shouldThrottle}`);
+                    rendered.isFinal &&
+                    existingMessageId &&
+                    Date.now() - (turn.lastPatchedAtByMessageId[existingMessageId] || 0) < 900;
+                this.options.log?.(`localcore-lark bridge event type=${event.type} sessionKey=${sessionKey} hasMessageId=${Boolean(existingMessageId)} throttle=${shouldThrottle}`);
                 if (shouldThrottle) {
                     return;
                 }
-                if (!turn.messageId) {
+                if (!existingMessageId) {
                     const createdId = await this.sendTextAsCard(state, route.chatId, rendered.text, rendered.buttonRows, sessionKey, binding.thread_id);
                     if (createdId) {
-                        turn.messageId = createdId;
-                        this.options.store.updatePlatformThreadMessageId(route.workspaceId, route.chatId, route.platformUserId, createdId);
+                        this.setRenderedMessageId(turn, rendered, createdId);
+                        if (rendered.isFinal) {
+                            this.options.store.updatePlatformThreadMessageId(route.workspaceId, route.chatId, route.platformUserId, createdId);
+                        }
                         this.options.log?.(`localcore-lark sent new card message ${createdId} for sessionKey=${sessionKey}`);
                     }
                     return;
                 }
-                await this.patchTextCard(state, turn.messageId, rendered.text, rendered.buttonRows, sessionKey, binding.thread_id);
+                await this.patchTextCard(state, existingMessageId, rendered.text, rendered.buttonRows, sessionKey, binding.thread_id);
                 turn.lastPatchedAt = Date.now();
-                this.options.log?.(`localcore-lark patched card message ${turn.messageId} for sessionKey=${sessionKey}`);
+                turn.lastPatchedAtByMessageId[existingMessageId] = turn.lastPatchedAt;
+                this.options.log?.(`localcore-lark patched card message ${existingMessageId} for sessionKey=${sessionKey}`);
             }
             catch (error) {
                 this.options.log?.(`localcore-lark bridge send failed for sessionKey=${sessionKey}: ${error instanceof Error ? error.message : String(error)}`);
@@ -447,7 +453,8 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
             return { paired: true, threadId };
         }
         this.options.store.clearPlatformThreadMessageId(input.workspaceId, input.chatId, input.platformUserId);
-        await router.sendThreadMessage(threadId, (0, desktop_js_1.wrapUserMessageWithSchedulerProtocol)(input.text));
+        const wrappedText = (0, desktop_js_1.wrapUserMessageWithSchedulerProtocol)(input.text);
+        await router.sendThreadMessage(threadId, this.createThreadMessageInput(wrappedText, input.contentParts));
         return { paired: true, threadId };
     }
     close() {
@@ -496,10 +503,12 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
             status: 'starting',
             connected: false,
             appId: binding.appId,
+            cardActionsEnabled: binding.cardActionsEnabled,
         };
         this.runtime.set(binding.workspaceId, status);
         this.notifyRuntimeStateChanged();
         try {
+            this.options.log?.(`localcore-lark starting workspace=${binding.workspaceId} app=${this.maskLarkAppId(binding.appId)} cardActions=${binding.cardActionsEnabled}`);
             const mod = await this.getLarkModule();
             status.client = new mod.Client({
                 appId: binding.appId,
@@ -514,8 +523,11 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
             });
             status.eventDispatcher.register({
                 'im.message.receive_v1': async (data) => {
-                    this.options.log?.(`localcore-lark received im.message.receive_v1 for ${binding.workspaceId}`);
-                    await this.handleMessageEvent(binding.workspaceId, data);
+                    this.options.log?.(`localcore-lark received im.message.receive_v1 for ${binding.workspaceId}: ${this.summarizeLarkEvent(data)}`);
+                    void this.handleMessageEvent(binding.workspaceId, data).catch((error) => {
+                        this.options.log?.(`localcore-lark inbound message failed for ${binding.workspaceId}: ${error instanceof Error ? error.message : String(error)}`);
+                    });
+                    return {};
                 },
                 'card.action.trigger': async (data) => {
                     this.options.log?.(`localcore-lark received card.action.trigger for ${binding.workspaceId}`);
@@ -523,12 +535,15 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
                     return {};
                 },
             });
+            this.options.log?.(`localcore-lark event dispatcher registered for ${binding.workspaceId}`);
             status.wsClient = new mod.WSClient({
                 appId: binding.appId,
                 appSecret: binding.appSecret,
                 domain: mod.Domain.Feishu,
                 loggerLevel: mod.LoggerLevel.info,
             });
+            this.attachWsDiagnostics(binding.workspaceId, status.wsClient);
+            this.options.log?.(`localcore-lark ws starting for ${binding.workspaceId}`);
             await status.wsClient.start({
                 eventDispatcher: status.eventDispatcher,
             });
@@ -536,6 +551,7 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
             status.connected = true;
             status.connectedAt = new Date().toISOString();
             status.lastError = undefined;
+            this.options.log?.(`localcore-lark ws ready for ${binding.workspaceId}`);
         }
         catch (error) {
             status.status = 'error';
@@ -550,10 +566,13 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
         if (!state) {
             return;
         }
+        this.options.log?.(`localcore-lark stopping workspace=${workspaceId} status=${state.status}`);
         try {
             await state.wsClient?.stop?.();
+            this.options.log?.(`localcore-lark stopped workspace=${workspaceId}`);
         }
-        catch {
+        catch (error) {
+            this.options.log?.(`localcore-lark stop failed for ${workspaceId}: ${error instanceof Error ? error.message : String(error)}`);
             // Best effort: current SDK versions may not implement stop().
         }
         this.runtime.set(workspaceId, {
@@ -562,6 +581,7 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
             status: 'stopped',
             connected: false,
             appId: state.appId,
+            cardActionsEnabled: state.cardActionsEnabled,
         });
         this.notifyRuntimeStateChanged();
     }
@@ -579,6 +599,7 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
             : data;
         const message = payload?.message;
         const sender = payload?.sender;
+        this.options.log?.(`localcore-lark handling message event for ${workspaceId}: ${this.summarizeLarkPayload(payload)}`);
         if (!message || !sender) {
             this.options.log?.(`localcore-lark ignored event without message/sender for ${workspaceId}: ${JSON.stringify(Object.keys(data || {}))}`);
             return;
@@ -590,18 +611,41 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
         catch {
             parsedContent = {};
         }
+        const messageType = String(message.message_type || '').trim().toLowerCase();
         const text = String(parsedContent.text || '').trim();
-        if (!text) {
-            this.options.log?.(`localcore-lark ignored non-text message for ${workspaceId}: ${String(message.message_type || 'unknown')}`);
+        const contentParts = [];
+        if (text) {
+            contentParts.push({ type: 'text', text });
+        }
+        if (messageType === 'image') {
+            const imageKey = String(parsedContent.image_key || parsedContent.file_key || '').trim();
+            if (imageKey) {
+                try {
+                    contentParts.push(await this.downloadMessageImage(workspaceId, String(message.message_id || ''), imageKey));
+                }
+                catch (error) {
+                    const errorText = `[Image download failed: ${error instanceof Error ? error.message : String(error)}]`;
+                    contentParts.push({ type: 'text', text: errorText });
+                    this.options.log?.(`localcore-lark image download failed for ${workspaceId}: message=${String(message.message_id || '')} imageKey=${imageKey} error=${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+        }
+        if (contentParts.length === 0) {
+            this.options.log?.(`localcore-lark ignored unsupported message for ${workspaceId}: type=${String(message.message_type || 'unknown')} contentKeys=${JSON.stringify(Object.keys(parsedContent))}`);
             return;
         }
+        const displayText = text || (contentParts.some((part) => part.type === 'image') ? '[Image]' : contentParts
+            .filter((part) => part.type === 'text')
+            .map((part) => part.text)
+            .join('\n\n')
+            .trim());
         const platformUserId = String(sender.sender_id?.user_id || sender.sender_id?.open_id || '').trim();
         const chatId = String(message.chat_id || platformUserId).trim();
         if (!platformUserId || !chatId) {
-            this.options.log?.(`localcore-lark ignored message without sender/chat for ${workspaceId}`);
+            this.options.log?.(`localcore-lark ignored message without sender/chat for ${workspaceId}: senderKeys=${JSON.stringify(Object.keys(sender?.sender_id || {}))} chat=${String(message.chat_id || '')}`);
             return;
         }
-        this.options.log?.(`localcore-lark inbound message for ${workspaceId}: chat=${chatId} user=${platformUserId} text=${JSON.stringify(text.slice(0, 120))}`);
+        this.options.log?.(`localcore-lark inbound message for ${workspaceId}: chat=${chatId} user=${platformUserId} type=${messageType || 'unknown'} text=${JSON.stringify(displayText.slice(0, 120))}`);
         await this.handleInboundMessage({
             workspaceId,
             platformUserId,
@@ -609,10 +653,164 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
             displayName: String(payload?.sender?.sender_id?.user_id ||
                 payload?.sender?.sender_id?.open_id ||
                 `Lark ${platformUserId.slice(-6)}`),
-            text,
+            text: displayText,
             messageId: String(message.message_id || (0, node_crypto_1.randomUUID)()),
+            contentParts,
         });
     }
+    createWrappedContentParts(wrappedText, parts) {
+        const nonTextParts = Array.isArray(parts)
+            ? parts.filter((part) => part.type !== 'text')
+            : [];
+        return [
+            { type: 'text', text: wrappedText },
+            ...nonTextParts,
+        ];
+    }
+    createThreadMessageInput(wrappedText, parts) {
+        const hasNonTextPart = Array.isArray(parts) && parts.some((part) => part.type !== 'text');
+        if (!hasNonTextPart) {
+            return wrappedText;
+        }
+        return {
+            displayText: wrappedText,
+            contentParts: this.createWrappedContentParts(wrappedText, parts),
+        };
+    }
+    async downloadMessageImage(workspaceId, messageId, imageKey) {
+        const state = this.runtime.get(workspaceId);
+        if (!state?.client) {
+            throw new Error('Lark client is not connected');
+        }
+        if (!messageId) {
+            throw new Error('Lark image message is missing message_id');
+        }
+        const resource = await state.client.im.messageResource.get({
+            path: {
+                message_id: messageId,
+                file_key: imageKey,
+            },
+            params: {
+                type: 'image',
+            },
+        });
+        const buffer = await this.readLarkResourceBuffer(resource);
+        if (buffer.length === 0) {
+            throw new Error('Lark image resource is empty');
+        }
+        const headerMime = this.extractHeaderMimeType(resource?.headers);
+        return {
+            type: 'image',
+            data: buffer.toString('base64'),
+            mimeType: headerMime || this.sniffImageMimeType(buffer),
+            fileName: `${imageKey}.${this.sniffImageExtension(buffer)}`,
+        };
+    }
+    async readLarkResourceBuffer(resource) {
+        const readable = resource?.getReadableStream?.();
+        if (!readable || typeof readable.on !== 'function') {
+            throw new Error('Lark resource did not provide a readable stream');
+        }
+        const chunks = [];
+        await new Promise((resolve, reject) => {
+            readable.on('data', (chunk) => {
+                chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+            });
+            readable.on('error', reject);
+            readable.on('end', resolve);
+        });
+        return Buffer.concat(chunks);
+    }
+    extractHeaderMimeType(headers) {
+        const value = headers && typeof headers === 'object'
+            ? headers['content-type'] || headers['Content-Type']
+            : '';
+        return String(value || '').split(';')[0]?.trim() || '';
+    }
+    sniffImageMimeType(buffer) {
+        if (buffer[0] === 0xff && buffer[1] === 0xd8)
+            return 'image/jpeg';
+        if (buffer[0] === 0x89 && buffer[1] === 0x50 && buffer[2] === 0x4e && buffer[3] === 0x47)
+            return 'image/png';
+        if (buffer[0] === 0x47 && buffer[1] === 0x49 && buffer[2] === 0x46)
+            return 'image/gif';
+        if (buffer[0] === 0x52 && buffer[1] === 0x49 && buffer[2] === 0x46 && buffer[3] === 0x46)
+            return 'image/webp';
+        return 'application/octet-stream';
+    }
+    sniffImageExtension(buffer) {
+        const mimeType = this.sniffImageMimeType(buffer);
+        if (mimeType === 'image/jpeg')
+            return 'jpg';
+        if (mimeType === 'image/png')
+            return 'png';
+        if (mimeType === 'image/gif')
+            return 'gif';
+        if (mimeType === 'image/webp')
+            return 'webp';
+        return 'bin';
+    }
+    attachWsDiagnostics(workspaceId, wsClient) {
+        const on = typeof wsClient?.on === 'function' ? wsClient.on.bind(wsClient) : null;
+        if (!on) {
+            this.options.log?.(`localcore-lark ws diagnostics unavailable for ${workspaceId}: client has no on()`);
+            return;
+        }
+        for (const eventName of ['open', 'connect', 'connected', 'ready', 'close', 'closed', 'disconnect', 'error', 'reconnect']) {
+            try {
+                on(eventName, (...args) => {
+                    this.options.log?.(`localcore-lark ws event ${eventName} for ${workspaceId}: ${this.summarizeWsArgs(args)}`);
+                });
+            }
+            catch (error) {
+                this.options.log?.(`localcore-lark ws diagnostic hook failed for ${workspaceId} event=${eventName}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+    }
+    summarizeLarkEvent(data) {
+        const payload = (data?.event && typeof data.event === 'object')
+            ? data.event
+            : data;
+        return this.summarizeLarkPayload(payload);
+    }
+    summarizeLarkPayload(payload) {
+        const message = payload?.message || {};
+        const sender = payload?.sender || {};
+        const senderId = sender?.sender_id || {};
+        const content = typeof message.content === 'string' ? message.content : '';
+        return [
+            `message=${String(message.message_id || '') || 'missing'}`,
+            `type=${String(message.message_type || '') || 'missing'}`,
+            `chat=${String(message.chat_id || '') || 'missing'}`,
+            `sender=${String(senderId.user_id || senderId.open_id || '') || 'missing'}`,
+            `contentBytes=${Buffer.byteLength(content, 'utf8')}`,
+            `keys=${JSON.stringify(Object.keys(payload || {}))}`,
+        ].join(' ');
+    }
+    summarizeWsArgs(args) {
+        if (args.length === 0) {
+            return 'no-args';
+        }
+        return args.map((arg) => {
+            if (arg instanceof Error) {
+                return `${arg.name}: ${arg.message}`;
+            }
+            if (typeof arg === 'string') {
+                return arg.slice(0, 200);
+            }
+            if (arg && typeof arg === 'object') {
+                return JSON.stringify(Object.keys(arg));
+            }
+            return String(arg);
+        }).join(' ');
+    }
+    maskLarkAppId(appId) {
+        const value = String(appId || '').trim();
+        if (value.length <= 8) {
+            return value ? '***' : '';
+        }
+        return `${value.slice(0, 6)}...${value.slice(-4)}`;
+    }
     collectBindings(config) {
         const projects = Array.isArray(config?.projects) ? config.projects : [];
         return projects.flatMap((project) => {
@@ -633,6 +831,10 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
                 verificationToken: String(platform.options.verification_token || '').trim(),
                 autoApprove: String(platform.options.auto_approve || '').trim().toLowerCase() === 'true'
                     || platform.options.auto_approve === true,
+                cardActionsEnabled: String(platform.options.card_actions || platform.options.enable_card_actions || '').trim().toLowerCase() === 'true'
+                    || platform.options.card_actions === true
+                    || platform.options.enable_card_actions === true
+                    || this.defaultCardActionsEnabled,
                 enabled: Boolean(String(platform.options.app_id || '').trim() && String(platform.options.app_secret || '').trim()),
                 project,
             }));
@@ -656,12 +858,12 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
                 tag: 'button',
                 text: {
                     tag: 'plain_text',
-                    content: button.text,
+                    content: this.formatPermissionButtonLabel(button),
                 },
-                type: index === 0 ? 'primary' : 'default',
+                type: this.resolveLarkButtonType(button, index),
                 value: {
                     action: 'permission_response',
-                    response: button.data,
+                    response: (0, desktop_js_1.normalizePermissionResponse)(button.data) || button.data,
                     session_key: sessionKey || '',
                     thread_id: threadId || '',
                 },
@@ -741,11 +943,13 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
             processing: false,
             previewText: '',
             finalText: '',
+            progressMessageIds: {},
             thinkingSteps: [],
             toolCalls: [],
             statusLines: [],
             buttonRows: [],
             lastPatchedAt: 0,
+            lastPatchedAtByMessageId: {},
         };
         this.outboundTurns.set(sessionKey, turn);
         return turn;
@@ -755,12 +959,14 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
         if (existing) {
             if (messageId && !existing.messageId) {
                 existing.messageId = messageId;
+                existing.finalMessageId = messageId;
             }
             return existing;
         }
         const turn = this.createTurnState(sessionKey);
         if (messageId) {
             turn.messageId = messageId;
+            turn.finalMessageId = messageId;
         }
         return turn;
     }
@@ -770,6 +976,8 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
             // Always start a fresh card for each generation phase.
             // This keeps Feishu message order aligned with user-visible timeline.
             turn.messageId = undefined;
+            turn.finalMessageId = undefined;
+            turn.progressMessageIds = {};
             turn.processing = true;
             turn.permissionMessageId = undefined;
             turn.previewText = '';
@@ -778,6 +986,7 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
             turn.toolCalls = [];
             turn.buttonRows = [];
             turn.statusLines = [];
+            turn.lastPatchedAtByMessageId = {};
             return;
         }
         if (event.type === 'typing_stop') {
@@ -796,15 +1005,7 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
         }
         if (event.type === 'buttons') {
             turn.awaitingPermission = true;
-            turn.buttonRows = this.enableCardActions && Array.isArray(event.buttonRows)
-                ? event.buttonRows
-                    .map((row) => Array.isArray(row)
-                    ? row
-                        .filter((button) => Boolean(button?.text && button?.data))
-                        .map((button) => ({ text: button.text, data: button.data }))
-                    : [])
-                    .filter((row) => row.length > 0)
-                : [];
+            turn.buttonRows = [];
             if (this.mirrorPermissionStateInMainCard && content) {
                 this.pushUnique(turn.statusLines, `等待确认: ${content}`);
             }
@@ -828,42 +1029,101 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
         turn.finalText = content;
         turn.previewText = content;
     }
-    renderTurnCard(turn) {
-        const sections = [];
-        if (turn.thinkingSteps.length > 0) {
-            sections.push(`**思考过程**\n${turn.thinkingSteps.map((step) => `• ${step.replace(/\s+/g, ' ').trim()}`).join('\n')}`);
-        }
-        if (turn.finalText) {
-            sections.push(turn.finalText);
+    renderBridgeEventMessage(turn, event) {
+        const content = String(event.content || '').trim();
+        if (event.type === 'preview_start' || event.type === 'update_message') {
+            if (content.startsWith('💭 ')) {
+                return this.renderProgressMessage(event.previewHandle || 'thinking-preview', content);
+            }
+            if (content.startsWith('🔧 ')) {
+                return this.renderProgressMessage(this.progressKey('tool', event), content);
+            }
+            return {
+                key: 'final',
+                text: content,
+                buttonRows: turn.buttonRows,
+                isFinal: true,
+            };
         }
-        else if (turn.previewText) {
-            sections.push(turn.previewText);
+        if (event.type === 'status') {
+            return this.renderProgressMessage(this.progressKey('status', event), content.startsWith('⏳ ') ? content : `⏳ ${content}`);
         }
-        else if (turn.processing && turn.toolCalls.length > 0) {
-            sections.push(`**处理中**\n${this.formatCompactToolLines(turn.toolCalls).join('\n')}`);
+        if (event.type === 'reply') {
+            if (content.startsWith('💭 ')) {
+                return this.renderProgressMessage(this.progressKey('thinking', event), content);
+            }
+            if (content.startsWith('🔧 ')) {
+                return this.renderProgressMessage(this.progressKey('tool', event), content);
+            }
+            if (content.startsWith('⏳ ') || content.startsWith('📤 ')) {
+                return this.renderProgressMessage(this.progressKey('status', event), content);
+            }
+            return {
+                key: 'final',
+                text: content,
+                buttonRows: turn.buttonRows,
+                isFinal: true,
+            };
         }
-        else if (turn.processing) {
-            sections.push('**处理中**\n正在思考...');
+        if (event.type === 'typing_start' || event.type === 'typing_stop') {
+            return { key: 'noop', text: '', buttonRows: [], isFinal: false };
         }
         return {
-            text: sections.join('\n\n').trim(),
-            buttonRows: turn.buttonRows,
+            key: 'noop',
+            text: '',
+            buttonRows: [],
+            isFinal: false,
+        };
+    }
+    renderProgressMessage(key, text) {
+        return {
+            key,
+            text,
+            buttonRows: [],
+            isFinal: false,
         };
     }
-    renderPermissionCard(turn, event) {
+    progressKey(prefix, event) {
+        const stableId = String(event.messageId || event.previewHandle || '').trim();
+        if (stableId) {
+            return `${prefix}:${stableId}`;
+        }
+        const content = String(event.content || '').trim().replace(/\s+/g, ' ');
+        return `${prefix}:${content.slice(0, 120)}`;
+    }
+    getRenderedMessageId(turn, rendered) {
+        if (rendered.isFinal) {
+            return turn.finalMessageId || turn.messageId;
+        }
+        return turn.progressMessageIds[rendered.key];
+    }
+    setRenderedMessageId(turn, rendered, messageId) {
+        if (rendered.isFinal) {
+            turn.finalMessageId = messageId;
+            turn.messageId = messageId;
+            return;
+        }
+        turn.progressMessageIds[rendered.key] = messageId;
+    }
+    renderPermissionCard(turn, event, cardActionsEnabled) {
         const summary = this.buildPermissionSummary(turn, String(event.content || '').trim());
         const sections = [
             '**需要工具确认**',
             summary.command ? `\`${summary.command}\`` : '',
             summary.reason || '',
-            '回复：`allow` / `allow all` / `deny`',
+            cardActionsEnabled
+                ? '也可以直接回复：`allow` / `allow all` / `deny`'
+                : '请直接回复：`allow` / `allow all` / `deny`',
         ].filter(Boolean);
-        const buttonRows = this.enableCardActions && Array.isArray(event.buttonRows)
+        const buttonRows = cardActionsEnabled && Array.isArray(event.buttonRows)
             ? event.buttonRows
                 .map((row) => Array.isArray(row)
                 ? row
                     .filter((button) => Boolean(button?.text && button?.data))
-                    .map((button) => ({ text: button.text, data: button.data }))
+                    .map((button) => ({
+                    text: this.formatPermissionButtonLabel(button),
+                    data: (0, desktop_js_1.normalizePermissionResponse)(button.data) || button.data,
+                }))
                 : [])
                 .filter((row) => row.length > 0)
             : [];
@@ -892,7 +1152,7 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
             if (!value || value.action !== 'permission_response') {
                 return;
             }
-            const response = String(value.response || '').trim();
+            const response = (0, desktop_js_1.normalizePermissionResponse)(String(value.response || '').trim()) || String(value.response || '').trim();
             const threadId = String(value.thread_id || '').trim();
             if (!response || !threadId) {
                 return;
@@ -918,6 +1178,29 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
             target.splice(0, target.length - 6);
         }
     }
+    formatPermissionButtonLabel(button) {
+        const response = (0, desktop_js_1.normalizePermissionResponse)(button.data) || (0, desktop_js_1.normalizePermissionResponse)(button.text);
+        switch (response) {
+            case 'allow':
+                return '允许一次';
+            case 'allow all':
+                return '始终允许';
+            case 'deny':
+                return '拒绝';
+            default:
+                return button.text;
+        }
+    }
+    resolveLarkButtonType(button, index) {
+        const response = (0, desktop_js_1.normalizePermissionResponse)(button.data) || (0, desktop_js_1.normalizePermissionResponse)(button.text);
+        if (response === 'deny') {
+            return 'danger';
+        }
+        if (response === 'allow') {
+            return 'primary';
+        }
+        return index === 0 ? 'primary' : 'default';
+    }
     buildPermissionSummary(turn, rawContent) {
         const lastTool = turn.toolCalls[turn.toolCalls.length - 1] || '';
         const [commandPart = '', reasonPart = ''] = lastTool.split(/\s+-\s+/, 2);