@kafca/agentdock 0.1.21 → 0.1.23

package/dist-electron/services/local-ai-core/src/{gateway → channel/lark}/local-core-lark-gateway.js

@@ -36,8 +36,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.LocalCoreLarkGateway = void 0;
 const node_events_1 = require("node:events");
 const node_crypto_1 = require("node:crypto");
-const desktop_js_1 = require("../../../../shared/desktop.js");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const desktop_js_1 = require("../../../../../shared/desktop.js");
+const file_utils_js_1 = require("../shared/file-utils.js");
+const cards_js_1 = require("./cards.js");
+const config_js_1 = require("./config.js");
+const registration_js_1 = require("./registration.js");
+const runtime_state_js_1 = require("./runtime-state.js");
 const PAIRING_EXPIRY_MS = 10 * 60 * 1000;
+const LARK_MAX_UPLOAD_FILE_SIZE = 30 * 1024 * 1024;
 class LocalCoreLarkGateway extends node_events_1.EventEmitter {
     options;
     // Lark returns 200340 when card action events are not enabled in the app's
@@ -60,25 +68,30 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
     async refreshBindings() {
         const config = await this.options.readConfig();
         const bindings = this.collectBindings(config);
-        const nextWorkspaceIds = new Set(bindings.map((binding) => binding.workspaceId));
-        for (const workspaceId of [...this.runtime.keys()]) {
-            if (!nextWorkspaceIds.has(workspaceId)) {
-                await this.stopWorkspace(workspaceId);
+        const nextKeys = new Set(bindings.map((binding) => (0, config_js_1.runtimeKey)(binding.workspaceId, binding.instanceId)));
+        for (const key of [...this.runtime.keys()]) {
+            if (!nextKeys.has(key)) {
+                await this.stopWorkspaceKey(key);
             }
         }
         for (const binding of bindings) {
-            const current = this.runtime.get(binding.workspaceId);
+            const key = (0, config_js_1.runtimeKey)(binding.workspaceId, binding.instanceId);
+            const current = this.runtime.get(key);
             if (!binding.enabled) {
                 if (current) {
-                    await this.stopWorkspace(binding.workspaceId);
+                    await this.stopWorkspaceKey(key);
                 }
                 else {
-                    this.runtime.set(binding.workspaceId, {
+                    this.runtime.set(key, {
                         workspaceId: binding.workspaceId,
+                        instanceId: binding.instanceId,
+                        displayName: binding.displayName,
+                        platformKey: binding.platformKey,
                         enabled: false,
                         status: 'disabled',
                         connected: false,
                         appId: binding.appId,
+                        autoApprove: binding.autoApprove,
                         cardActionsEnabled: binding.cardActionsEnabled,
                     });
                 }
@@ -91,23 +104,70 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
         }
         this.notifyRuntimeStateChanged();
     }
-    async testConnection(workspaceId) {
-        const binding = await this.getBinding(workspaceId);
+    async testConnection(workspaceId, instanceId) {
+        const binding = await this.getBinding(workspaceId, instanceId);
         const result = await this.createSdkClientResult(binding);
         return {
             ...result,
             platform: 'lark',
             workspaceId,
+            instanceId: binding.instanceId,
         };
     }
-    async enable(workspaceId) {
-        const binding = await this.getBinding(workspaceId);
+    async enable(workspaceId, instanceId) {
+        const binding = await this.getBinding(workspaceId, instanceId);
         await this.startWorkspace(binding);
-        return this.getStatus(workspaceId);
+        return this.getStatus(workspaceId, binding.instanceId);
     }
-    async disable(workspaceId) {
-        await this.stopWorkspace(workspaceId);
-        return this.getStatus(workspaceId);
+    async disable(workspaceId, instanceId) {
+        await this.stopWorkspace(workspaceId, instanceId);
+        return this.getStatus(workspaceId, instanceId);
+    }
+    async getQrCode(workspaceId, instanceId) {
+        const binding = await this.getBinding(workspaceId, instanceId);
+        const data = await (0, registration_js_1.requestAppRegistration)(binding);
+        const ticket = String(data.device_code || '').trim();
+        const userCode = String(data.user_code || '').trim();
+        if (!ticket || !userCode) {
+            throw new Error('Lark app registration did not return a device code and user code.');
+        }
+        return {
+            ticket,
+            expiresIn: Number(data.expires_in || registration_js_1.DEFAULT_LARK_QR_EXPIRES_IN) || registration_js_1.DEFAULT_LARK_QR_EXPIRES_IN,
+            interval: Number(data.interval || 5) || 5,
+            qrCodeUrl: `${(0, registration_js_1.getLarkOpenBase)(binding)}${registration_js_1.LARK_APP_REGISTRATION_SETUP_PATH}?user_code=${encodeURIComponent(userCode)}&from=openclaw`,
+            instanceId: binding.instanceId,
+            displayName: binding.displayName,
+        };
+    }
+    async checkQrCodeStatus(workspaceId, ticket, instanceId) {
+        const binding = await this.getBinding(workspaceId, instanceId);
+        const data = await (0, registration_js_1.pollAppRegistration)(binding, ticket);
+        const error = String(data.error || '').trim();
+        if (error === 'authorization_pending' || error === 'slow_down') {
+            return { status: 'wait' };
+        }
+        if (error === 'expired_token' || error === 'invalid_grant') {
+            return { status: 'expired' };
+        }
+        if (error === 'access_denied') {
+            throw new Error('Lark app registration was rejected.');
+        }
+        if (error) {
+            throw new Error(`Lark app registration failed: ${String(data.error_description || error)}`);
+        }
+        const appId = String(data.client_id || '').trim();
+        const appSecret = String(data.client_secret || '').trim();
+        if (!appId || !appSecret) {
+            return { status: 'wait' };
+        }
+        return {
+            status: 'confirmed',
+            credentials: {
+                appId,
+                appSecret,
+            },
+        };
     }
     async sendScheduledCard(workspaceId, chatId, text) {
         return this.sendImmediateCard(workspaceId, chatId, text);
@@ -115,6 +175,111 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
     async sendScheduledMessage(workspaceId, route, text) {
         return this.sendScheduledCard(workspaceId, route.channelId, text);
     }
+    async sendOutboundMessage(workspaceId, input) {
+        const state = this.resolveRuntimeState(workspaceId, input.route?.instanceId).state;
+        if (!state?.client || !state.connected) {
+            throw new Error(`Lark workspace is not connected: ${workspaceId}`);
+        }
+        const channelId = String(input.route?.channelId || '').trim();
+        if (!channelId) {
+            throw new Error('Missing Lark target channel id');
+        }
+        const messageIds = [];
+        const attachments = [];
+        for (const part of input.parts || []) {
+            if (part.type === 'text') {
+                const text = String(part.text || '').trim();
+                if (text) {
+                    messageIds.push(await this.sendTextAsCard(state, channelId, text));
+                }
+                continue;
+            }
+            if (part.type === 'file') {
+                const sent = await this.sendFilePart(state, channelId, part);
+                messageIds.push(sent.messageId);
+                attachments.push({
+                    kind: 'file',
+                    attachmentId: sent.fileKey,
+                    fileName: sent.file.fileName,
+                    fileSize: sent.file.fileSize,
+                    metadata: {
+                        fileKey: sent.fileKey,
+                    },
+                });
+            }
+        }
+        return {
+            platform: 'lark',
+            workspaceId,
+            channelId,
+            participantId: input.route.participantId,
+            messageIds: messageIds.filter(Boolean),
+            attachments,
+        };
+    }
+    async sendFile(workspaceId, input) {
+        const result = await this.sendOutboundMessage(workspaceId, {
+            route: {
+                type: 'channel.chat',
+                channelId: input.channelId,
+                participantId: input.participantId,
+            },
+            parts: [{
+                    type: 'file',
+                    path: input.path,
+                    fileName: input.fileName,
+                }],
+        });
+        const attachment = result.attachments?.[0];
+        return {
+            platform: 'lark',
+            workspaceId,
+            channelId: result.channelId,
+            messageId: result.messageIds[0] || '',
+            fileKey: String(attachment?.metadata?.fileKey || attachment?.attachmentId || ''),
+            fileName: attachment?.fileName || input.fileName || '',
+            fileSize: attachment?.fileSize || 0,
+        };
+    }
+    async sendFilePart(state, channelId, part) {
+        const file = await (0, file_utils_js_1.prepareChannelFile)({
+            path: part.path,
+            fileName: part.fileName,
+            maxBytes: LARK_MAX_UPLOAD_FILE_SIZE,
+            platformLabel: 'Lark',
+        });
+        const upload = await state.client.im.file.create({
+            data: {
+                file_type: this.resolveLarkUploadFileType(file.fileName),
+                file_name: file.fileName,
+                file: (0, node_fs_1.createReadStream)(file.path),
+            },
+        });
+        const fileKey = String(upload?.file_key || upload?.data?.file_key || '').trim();
+        if (!fileKey) {
+            throw new Error('Lark file upload did not return a file key');
+        }
+        const response = await state.client.im.message.create({
+            params: {
+                receive_id_type: this.resolveReceiveIdType(channelId),
+            },
+            data: {
+                receive_id: channelId,
+                msg_type: 'file',
+                content: JSON.stringify({ file_key: fileKey }),
+            },
+        });
+        const messageId = String(response?.data?.message_id || '').trim();
+        if (!messageId) {
+            throw new Error('Lark file message did not return a message id');
+        }
+        this.options.log?.(`localcore-lark sent file ${file.fileName} (${file.fileSize} bytes) to ${channelId}`);
+        return {
+            messageId,
+            fileKey,
+            file,
+        };
+    }
     muteThreadBridge(threadId) {
         const current = this.mutedThreadBridgeCounts.get(threadId) || 0;
         this.mutedThreadBridgeCounts.set(threadId, current + 1);
@@ -127,15 +292,19 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
         }
         this.mutedThreadBridgeCounts.set(threadId, current - 1);
     }
-    getStatus(workspaceId) {
+    getStatus(workspaceId, instanceId) {
         this.options.store.expirePendingPairings();
-        const binding = this.runtime.get(workspaceId);
+        const resolved = this.resolveRuntimeState(workspaceId, instanceId);
+        const binding = resolved.state;
+        const platformKey = binding?.platformKey || (0, config_js_1.channelPlatformKey)('lark', resolved.instanceId);
         const pairings = this.options.store.listPendingPairings(workspaceId)
-            .filter((row) => row.platform === 'lark' && row.expires_at >= new Date().toISOString());
-        const users = this.options.store.listAuthorizedUsers(workspaceId, 'lark');
+            .filter((row) => row.platform === platformKey && row.expires_at >= new Date().toISOString());
+        const users = this.options.store.listAuthorizedUsers(workspaceId, platformKey);
         return {
             workspaceId,
             platform: 'lark',
+            instanceId: resolved.instanceId,
+            displayName: binding?.displayName,
             enabled: Boolean(binding?.enabled),
             connected: Boolean(binding?.connected),
             status: binding?.status || 'disabled',
@@ -147,16 +316,20 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
         };
     }
     listStatuses() {
-        return [...this.runtime.keys()].sort().map((workspaceId) => this.getStatus(workspaceId));
+        return [...this.runtime.values()]
+            .sort((a, b) => `${a.workspaceId}:${a.instanceId}`.localeCompare(`${b.workspaceId}:${b.instanceId}`))
+            .map((state) => this.getStatus(state.workspaceId, state.instanceId));
     }
     listPendingPairings(workspaceId) {
         this.options.store.expirePendingPairings();
         return this.options.store
-            .listPairingRequests(workspaceId, 'lark')
+            .listPairingRequests(workspaceId)
+            .filter((item) => item.platform === 'lark' || item.platform.startsWith('lark:'))
             .filter((item) => item.status === 'pending' && item.expiresAt >= new Date().toISOString());
     }
     listAuthorizedUsers(workspaceId) {
-        return this.options.store.listAuthorizedUsers(workspaceId, 'lark');
+        return this.options.store.listAuthorizedUsers(workspaceId)
+            .filter((item) => item.platform === 'lark' || item.platform.startsWith('lark:'));
     }
     async start() {
         await this.refreshBindings();
@@ -170,7 +343,7 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
         if (!pairing) {
             throw new Error(`Pairing code not found: ${code}`);
         }
-        if (pairing.platform !== 'lark') {
+        if (pairing.platform !== 'lark' && !pairing.platform.startsWith('lark:')) {
             throw new Error(`Pairing code ${code} is not a Lark pairing`);
         }
         if (pairing.status !== 'pending') {
@@ -180,12 +353,13 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
             this.options.store.updatePairingStatus(code, 'expired');
             throw new Error(`Pairing code ${code} has expired`);
         }
-        const existing = this.options.store.getAuthorizedUser(pairing.workspace_id, pairing.platform_user_id);
+        const existing = this.options.store.getAuthorizedUser(pairing.workspace_id, pairing.platform_user_id, pairing.platform);
         const userId = existing?.id || `lark-user-${(0, node_crypto_1.randomUUID)()}`;
         const authorizedAt = new Date().toISOString();
         this.options.store.createAuthorizedUser({
             id: userId,
             workspace_id: pairing.workspace_id,
+            platform: pairing.platform,
             platform_user_id: pairing.platform_user_id,
             chat_id: pairing.chat_id,
             display_name: pairing.display_name,
@@ -194,7 +368,7 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
         });
         this.options.store.updatePairingStatus(code, 'approved');
         this.notifyRuntimeStateChanged();
-        const user = this.options.store.listAuthorizedUsers(pairing.workspace_id, 'lark').find((entry) => entry.id === userId);
+        const user = this.options.store.listAuthorizedUsers(pairing.workspace_id, pairing.platform).find((entry) => entry.id === userId);
         if (!user) {
             throw new Error('Authorized user lookup failed after approval');
         }
@@ -220,12 +394,14 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
             this.options.log?.(`localcore-lark bridge route miss for sessionKey=${sessionKey} type=${event.type}`);
             return;
         }
-        const state = this.runtime.get(route.workspaceId);
+        const routeInstanceId = route.instanceId || 'default';
+        const routePlatformKey = route.platformKey || (0, config_js_1.channelPlatformKey)('lark', routeInstanceId);
+        const state = this.runtime.get((0, config_js_1.runtimeKey)(route.workspaceId, routeInstanceId)) || this.runtime.get(route.workspaceId);
         if (!state?.client || !state.connected) {
             this.options.log?.(`localcore-lark bridge event ignored because workspace is not connected: ${route.workspaceId}`);
             return;
         }
-        const initialBinding = this.options.store.getPlatformThreadBinding(route.workspaceId, route.chatId, route.platformUserId);
+        const initialBinding = this.options.store.getPlatformThreadBinding(route.workspaceId, route.chatId, route.platformUserId, routePlatformKey);
         if (!initialBinding) {
             this.options.log?.(`localcore-lark bridge binding miss for workspace=${route.workspaceId} chat=${route.chatId} user=${route.platformUserId}`);
             return;
@@ -244,7 +420,7 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
         const current = previous
             .catch(() => undefined)
             .then(async () => {
-            const binding = this.options.store.getPlatformThreadBinding(route.workspaceId, route.chatId, route.platformUserId);
+            const binding = this.options.store.getPlatformThreadBinding(route.workspaceId, route.chatId, route.platformUserId, routePlatformKey);
             if (!binding) {
                 this.options.log?.(`localcore-lark bridge binding disappeared for sessionKey=${sessionKey}`);
                 return;
@@ -273,7 +449,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, Boolean(state.cardActionsEnabled));
+                    const permissionCard = (0, cards_js_1.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);
@@ -291,12 +467,12 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
                     return;
                 }
                 this.consumeBridgeEvent(turn, event);
-                const rendered = this.renderBridgeEventMessage(turn, event);
+                const rendered = (0, runtime_state_js_1.renderLarkBridgeEventMessage)(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 existingMessageId = (0, runtime_state_js_1.getLarkRenderedMessageId)(turn, rendered);
                 const shouldThrottle = event.type === 'update_message' &&
                     rendered.isFinal &&
                     existingMessageId &&
@@ -308,9 +484,9 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
                 if (!existingMessageId) {
                     const createdId = await this.sendTextAsCard(state, route.chatId, rendered.text, rendered.buttonRows, sessionKey, binding.thread_id);
                     if (createdId) {
-                        this.setRenderedMessageId(turn, rendered, createdId);
+                        (0, runtime_state_js_1.setLarkRenderedMessageId)(turn, rendered, createdId);
                         if (rendered.isFinal) {
-                            this.options.store.updatePlatformThreadMessageId(route.workspaceId, route.chatId, route.platformUserId, createdId);
+                            this.options.store.updatePlatformThreadMessageId(route.workspaceId, route.chatId, route.platformUserId, createdId, routePlatformKey);
                         }
                         this.options.log?.(`localcore-lark sent new card message ${createdId} for sessionKey=${sessionKey}`);
                     }
@@ -334,6 +510,8 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
         await current;
     }
     async handleInboundMessage(input) {
+        const instanceId = input.instanceId || 'default';
+        const platformKey = input.platformKey || (0, config_js_1.channelPlatformKey)('lark', instanceId);
         this.options.eventBus.emit({
             type: 'platform.message.received',
             payload: {
@@ -347,27 +525,38 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
             },
         });
         this.options.store.expirePendingPairings();
-        const binding = await this.getBinding(input.workspaceId);
-        let authorized = this.options.store.getAuthorizedUser(input.workspaceId, input.platformUserId);
+        const runtimeState = this.resolveRuntimeState(input.workspaceId, instanceId).state;
+        let binding;
+        try {
+            binding = await this.getBinding(input.workspaceId, instanceId);
+        }
+        catch (error) {
+            if (!runtimeState) {
+                throw error;
+            }
+            this.options.log?.(`localcore-lark using active runtime binding snapshot for ${input.workspaceId}/${instanceId}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        let authorized = this.options.store.getAuthorizedUser(input.workspaceId, input.platformUserId, platformKey);
         if (!authorized) {
-            if (binding.autoApprove) {
+            if (binding?.autoApprove || runtimeState?.autoApprove) {
                 const authorizedAt = new Date().toISOString();
                 this.options.store.createAuthorizedUser({
                     id: `lark-user-${(0, node_crypto_1.randomUUID)()}`,
                     workspace_id: input.workspaceId,
+                    platform: platformKey,
                     platform_user_id: input.platformUserId,
                     chat_id: input.chatId,
                     display_name: input.displayName,
                     thread_id: null,
                     authorized_at: authorizedAt,
                 });
-                authorized = this.options.store.getAuthorizedUser(input.workspaceId, input.platformUserId);
+                authorized = this.options.store.getAuthorizedUser(input.workspaceId, input.platformUserId, platformKey);
                 this.options.log?.(`localcore-lark auto-approved user for ${input.workspaceId}: ${input.platformUserId}`);
                 this.notifyRuntimeStateChanged();
             }
         }
         if (!authorized) {
-            const existingPending = this.options.store.listPendingPairings(input.workspaceId).find((item) => item.platform === 'lark' && item.platform_user_id === input.platformUserId && item.chat_id === input.chatId && item.status === 'pending');
+            const existingPending = this.options.store.listPendingPairings(input.workspaceId).find((item) => item.platform === platformKey && item.platform_user_id === input.platformUserId && item.chat_id === input.chatId && item.status === 'pending');
             let pairingCode = existingPending?.code || '';
             if (!existingPending) {
                 const now = new Date();
@@ -375,6 +564,7 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
                 this.options.store.createPairingRequest({
                     code: pairingCode,
                     workspace_id: input.workspaceId,
+                    platform: platformKey,
                     platform_user_id: input.platformUserId,
                     chat_id: input.chatId,
                     display_name: input.displayName,
@@ -384,19 +574,20 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
                 });
                 this.notifyRuntimeStateChanged();
             }
-            await this.sendImmediateCard(input.workspaceId, input.chatId, this.renderPendingPairingCard(pairingCode));
+            await this.sendImmediateCard(input.workspaceId, input.chatId, (0, cards_js_1.renderPendingPairingCard)(pairingCode), instanceId);
             return { paired: false };
         }
         const router = this.options.getWorkspaceRouter();
-        const threadBinding = this.options.store.getPlatformThreadBinding(input.workspaceId, input.chatId, input.platformUserId);
+        const threadBinding = this.options.store.getPlatformThreadBinding(input.workspaceId, input.chatId, input.platformUserId, platformKey);
         let threadId = threadBinding?.thread_id || authorized.thread_id || '';
         if (!threadId) {
             const thread = await router.createThread(input.workspaceId, input.displayName || `Lark ${input.chatId}`);
             threadId = thread.id;
-            this.options.store.updateAuthorizedUserThread(input.workspaceId, input.platformUserId, threadId);
+            this.options.store.updateAuthorizedUserThread(input.workspaceId, input.platformUserId, threadId, platformKey);
             const now = new Date().toISOString();
             this.options.store.upsertPlatformThreadBinding({
                 workspace_id: input.workspaceId,
+                platform: platformKey,
                 chat_id: input.chatId,
                 platform_user_id: input.platformUserId,
                 thread_id: threadId,
@@ -416,20 +607,23 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
         const effectiveSessionKey = this.options.getWorkspaceRouter().getThreadSessionKey(threadId);
         this.threadRouting.set(effectiveSessionKey, {
             workspaceId: input.workspaceId,
+            instanceId,
+            platformKey,
             platformUserId: input.platformUserId,
             chatId: input.chatId,
             threadId,
         });
         const acknowledgement = this.createTurnState(effectiveSessionKey, input.messageId);
-        await this.addAcknowledgementReaction(input.workspaceId, input.messageId, acknowledgement);
+        await this.addAcknowledgementReaction(input.workspaceId, input.messageId, acknowledgement, instanceId);
         const slashCommand = this.parseSlashCommand(input.text);
         if (slashCommand?.name === 'new') {
             const title = slashCommand.args.join(' ').trim() || `${input.displayName || 'Lark'} ${new Date().toLocaleTimeString()}`;
             const nextThread = await router.createThread(input.workspaceId, title);
             const now = new Date().toISOString();
-            this.options.store.updateAuthorizedUserThread(input.workspaceId, input.platformUserId, nextThread.id);
+            this.options.store.updateAuthorizedUserThread(input.workspaceId, input.platformUserId, nextThread.id, platformKey);
             this.options.store.upsertPlatformThreadBinding({
                 workspace_id: input.workspaceId,
+                platform: platformKey,
                 chat_id: input.chatId,
                 platform_user_id: input.platformUserId,
                 thread_id: nextThread.id,
@@ -439,11 +633,13 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
             });
             this.threadRouting.set(this.options.getWorkspaceRouter().getThreadSessionKey(nextThread.id), {
                 workspaceId: input.workspaceId,
+                instanceId,
+                platformKey,
                 platformUserId: input.platformUserId,
                 chatId: input.chatId,
                 threadId: nextThread.id,
             });
-            await this.sendImmediateCard(input.workspaceId, input.chatId, '**已开始新会话**');
+            await this.sendImmediateCard(input.workspaceId, input.chatId, '**已开始新会话**', instanceId);
             return { paired: true, threadId: nextThread.id };
         }
         const latestRun = this.options.store.getLatestRunForThread(threadId);
@@ -458,13 +654,25 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
         return { paired: true, threadId };
     }
     close() {
-        return Promise.all([...this.runtime.keys()].map((workspaceId) => this.stopWorkspace(workspaceId))).then(() => undefined);
+        return Promise.all([...this.runtime.keys()].map((key) => this.stopWorkspaceKey(key))).then(() => undefined);
     }
-    async getBinding(workspaceId) {
+    resolveRuntimeState(workspaceId, instanceId) {
+        if (instanceId) {
+            const state = this.runtime.get((0, config_js_1.runtimeKey)(workspaceId, instanceId)) || (instanceId === 'default' ? this.runtime.get(workspaceId) : undefined);
+            return { instanceId, state };
+        }
+        const states = [...this.runtime.values()].filter((entry) => entry.workspaceId === workspaceId);
+        const state = states.find((entry) => entry.instanceId === 'default') || states[0];
+        return { instanceId: state?.instanceId || 'default', state: state || this.runtime.get(workspaceId) };
+    }
+    async getBinding(workspaceId, instanceId) {
         const config = await this.options.readConfig();
-        const binding = this.collectBindings(config).find((entry) => entry.workspaceId === workspaceId);
+        const bindings = this.collectBindings(config).filter((entry) => entry.workspaceId === workspaceId);
+        const binding = instanceId
+            ? bindings.find((entry) => entry.instanceId === instanceId)
+            : bindings.find((entry) => entry.instanceId === 'default') || bindings[0];
         if (!binding) {
-            throw new Error(`No Lark binding configured for workspace "${workspaceId}"`);
+            throw new Error(`No Lark binding configured for workspace "${workspaceId}"${instanceId ? ` instance "${instanceId}"` : ''}`);
         }
         return binding;
     }
@@ -482,6 +690,7 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
                 success: true,
                 platform: 'lark',
                 workspaceId: binding.workspaceId,
+                instanceId: binding.instanceId,
                 appId: binding.appId,
             };
         }
@@ -490,22 +699,28 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
                 success: false,
                 platform: 'lark',
                 workspaceId: binding.workspaceId,
+                instanceId: binding.instanceId,
                 appId: binding.appId,
                 error: error instanceof Error ? error.message : String(error),
             };
         }
     }
     async startWorkspace(binding) {
-        await this.stopWorkspace(binding.workspaceId);
+        const key = (0, config_js_1.runtimeKey)(binding.workspaceId, binding.instanceId);
+        await this.stopWorkspaceKey(key);
         const status = {
             workspaceId: binding.workspaceId,
+            instanceId: binding.instanceId,
+            displayName: binding.displayName,
+            platformKey: binding.platformKey,
             enabled: true,
             status: 'starting',
             connected: false,
             appId: binding.appId,
+            autoApprove: binding.autoApprove,
             cardActionsEnabled: binding.cardActionsEnabled,
         };
-        this.runtime.set(binding.workspaceId, status);
+        this.runtime.set(key, status);
         this.notifyRuntimeStateChanged();
         try {
             this.options.log?.(`localcore-lark starting workspace=${binding.workspaceId} app=${this.maskLarkAppId(binding.appId)} cardActions=${binding.cardActionsEnabled}`);
@@ -523,15 +738,15 @@ 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}: ${this.summarizeLarkEvent(data)}`);
-                    void this.handleMessageEvent(binding.workspaceId, data).catch((error) => {
+                    this.options.log?.(`localcore-lark received im.message.receive_v1 for ${binding.workspaceId}/${binding.instanceId}: ${this.summarizeLarkEvent(data)}`);
+                    void this.handleMessageEvent(binding.workspaceId, binding.instanceId, binding.platformKey, 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}`);
-                    void this.handleCardActionEvent(binding.workspaceId, data);
+                    this.options.log?.(`localcore-lark received card.action.trigger for ${binding.workspaceId}/${binding.instanceId}`);
+                    void this.handleCardActionEvent(binding.workspaceId, binding.instanceId, data);
                     return {};
                 },
             });
@@ -561,26 +776,34 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
         }
         this.notifyRuntimeStateChanged();
     }
-    async stopWorkspace(workspaceId) {
-        const state = this.runtime.get(workspaceId);
+    async stopWorkspace(workspaceId, instanceId) {
+        const resolved = this.resolveRuntimeState(workspaceId, instanceId);
+        await this.stopWorkspaceKey((0, config_js_1.runtimeKey)(workspaceId, resolved.instanceId));
+    }
+    async stopWorkspaceKey(key) {
+        const state = this.runtime.get(key);
         if (!state) {
             return;
         }
-        this.options.log?.(`localcore-lark stopping workspace=${workspaceId} status=${state.status}`);
+        this.options.log?.(`localcore-lark stopping workspace=${state.workspaceId}/${state.instanceId} status=${state.status}`);
         try {
             await state.wsClient?.stop?.();
-            this.options.log?.(`localcore-lark stopped workspace=${workspaceId}`);
+            this.options.log?.(`localcore-lark stopped workspace=${state.workspaceId}/${state.instanceId}`);
         }
         catch (error) {
-            this.options.log?.(`localcore-lark stop failed for ${workspaceId}: ${error instanceof Error ? error.message : String(error)}`);
+            this.options.log?.(`localcore-lark stop failed for ${state.workspaceId}/${state.instanceId}: ${error instanceof Error ? error.message : String(error)}`);
             // Best effort: current SDK versions may not implement stop().
         }
-        this.runtime.set(workspaceId, {
-            workspaceId,
+        this.runtime.set(key, {
+            workspaceId: state.workspaceId,
+            instanceId: state.instanceId,
+            displayName: state.displayName,
+            platformKey: state.platformKey,
             enabled: false,
             status: 'stopped',
             connected: false,
             appId: state.appId,
+            autoApprove: state.autoApprove,
             cardActionsEnabled: state.cardActionsEnabled,
         });
         this.notifyRuntimeStateChanged();
@@ -593,7 +816,11 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
             },
         });
     }
-    async handleMessageEvent(workspaceId, data) {
+    async handleMessageEvent(workspaceId, instanceIdOrData, platformKeyOrData, maybeData) {
+        const legacyCall = typeof instanceIdOrData === 'object';
+        const instanceId = legacyCall ? 'default' : instanceIdOrData;
+        const platformKey = legacyCall ? 'lark' : String(platformKeyOrData || (0, config_js_1.channelPlatformKey)('lark', instanceId));
+        const data = (legacyCall ? instanceIdOrData : maybeData) || {};
         const payload = (data?.event && typeof data.event === 'object')
             ? data.event
             : data;
@@ -621,7 +848,7 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
             const imageKey = String(parsedContent.image_key || parsedContent.file_key || '').trim();
             if (imageKey) {
                 try {
-                    contentParts.push(await this.downloadMessageImage(workspaceId, String(message.message_id || ''), imageKey));
+                    contentParts.push(await this.downloadMessageImage(workspaceId, String(message.message_id || ''), imageKey, instanceId));
                 }
                 catch (error) {
                     const errorText = `[Image download failed: ${error instanceof Error ? error.message : String(error)}]`;
@@ -648,6 +875,8 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
         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,
+            instanceId,
+            platformKey,
             platformUserId,
             chatId,
             displayName: String(payload?.sender?.sender_id?.user_id ||
@@ -677,8 +906,8 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
             contentParts: this.createWrappedContentParts(wrappedText, parts),
         };
     }
-    async downloadMessageImage(workspaceId, messageId, imageKey) {
-        const state = this.runtime.get(workspaceId);
+    async downloadMessageImage(workspaceId, messageId, imageKey, instanceId) {
+        const state = this.resolveRuntimeState(workspaceId, instanceId).state;
         if (!state?.client) {
             throw new Error('Lark client is not connected');
         }
@@ -812,32 +1041,8 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
         return `${value.slice(0, 6)}...${value.slice(-4)}`;
     }
     collectBindings(config) {
-        const projects = Array.isArray(config?.projects) ? config.projects : [];
-        return projects.flatMap((project) => {
-            const platforms = Array.isArray(project.platforms) ? project.platforms : [];
-            return platforms
-                .map((platform) => ({
-                platformType: (0, desktop_js_1.normalizeDesktopPlatformType)(platform?.type),
-                options: platform?.options && typeof platform.options === 'object'
-                    ? platform.options
-                    : {},
-            }))
-                .filter((platform) => platform.platformType === 'lark')
-                .map((platform) => ({
-                workspaceId: project.name,
-                appId: String(platform.options.app_id || '').trim(),
-                appSecret: String(platform.options.app_secret || '').trim(),
-                encryptKey: String(platform.options.encrypt_key || '').trim(),
-                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,
-            }));
+        return (0, config_js_1.collectLarkWorkspaceBindings)(config, {
+            defaultCardActionsEnabled: this.defaultCardActionsEnabled,
         });
     }
     async getLarkModule() {
@@ -846,61 +1051,53 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
         }
         return this.larkModulePromise;
     }
-    buildInteractiveCard(text, buttonRows = [], sessionKey, threadId) {
-        const elements = [];
-        if (text) {
-            elements.push({ tag: 'markdown', content: text });
-        }
-        for (const row of buttonRows) {
-            const actions = row
-                .filter((button) => button.text && button.data)
-                .map((button, index) => ({
-                tag: 'button',
-                text: {
-                    tag: 'plain_text',
-                    content: this.formatPermissionButtonLabel(button),
-                },
-                type: this.resolveLarkButtonType(button, index),
-                value: {
-                    action: 'permission_response',
-                    response: (0, desktop_js_1.normalizePermissionResponse)(button.data) || button.data,
-                    session_key: sessionKey || '',
-                    thread_id: threadId || '',
-                },
-            }));
-            if (actions.length) {
-                elements.push({
-                    tag: 'action',
-                    actions,
-                });
-            }
-        }
-        return {
-            config: { wide_screen_mode: true },
-            elements,
-        };
-    }
     async sendTextAsCard(state, chatId, text, buttonRows = [], sessionKey, threadId) {
-        const receiveIdType = chatId.startsWith('oc_') ? 'chat_id' : chatId.startsWith('ou_') ? 'open_id' : 'user_id';
         const response = await state.client.im.message.create({
             params: {
-                receive_id_type: receiveIdType,
+                receive_id_type: this.resolveReceiveIdType(chatId),
             },
             data: {
                 receive_id: chatId,
                 msg_type: 'interactive',
-                content: JSON.stringify(this.buildInteractiveCard(text, buttonRows, sessionKey, threadId)),
+                content: JSON.stringify((0, cards_js_1.buildInteractiveCard)(text, buttonRows, sessionKey, threadId)),
             },
         });
         return String(response?.data?.message_id || '').trim();
     }
+    resolveReceiveIdType(receiveId) {
+        return receiveId.startsWith('oc_') ? 'chat_id' : receiveId.startsWith('ou_') ? 'open_id' : 'user_id';
+    }
+    resolveLarkUploadFileType(fileName) {
+        switch ((0, node_path_1.extname)(fileName).toLowerCase()) {
+            case '.opus':
+                return 'opus';
+            case '.mp4':
+            case '.mov':
+            case '.m4v':
+                return 'mp4';
+            case '.pdf':
+                return 'pdf';
+            case '.doc':
+            case '.docx':
+                return 'doc';
+            case '.xls':
+            case '.xlsx':
+            case '.csv':
+                return 'xls';
+            case '.ppt':
+            case '.pptx':
+                return 'ppt';
+            default:
+                return 'stream';
+        }
+    }
     async patchTextCard(state, messageId, text, buttonRows = [], sessionKey, threadId) {
         await state.client.im.message.patch({
             path: {
                 message_id: messageId,
             },
             data: {
-                content: JSON.stringify(this.buildInteractiveCard(text, buttonRows, sessionKey, threadId)),
+                content: JSON.stringify((0, cards_js_1.buildInteractiveCard)(text, buttonRows, sessionKey, threadId)),
             },
         });
     }
@@ -936,21 +1133,7 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
         };
     }
     createTurnState(sessionKey, sourceMessageId) {
-        const turn = {
-            sessionKey,
-            sourceMessageId,
-            awaitingPermission: false,
-            processing: false,
-            previewText: '',
-            finalText: '',
-            progressMessageIds: {},
-            thinkingSteps: [],
-            toolCalls: [],
-            statusLines: [],
-            buttonRows: [],
-            lastPatchedAt: 0,
-            lastPatchedAtByMessageId: {},
-        };
+        const turn = (0, runtime_state_js_1.createLarkTurnState)(sessionKey, sourceMessageId);
         this.outboundTurns.set(sessionKey, turn);
         return turn;
     }
@@ -971,258 +1154,57 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
         return turn;
     }
     consumeBridgeEvent(turn, event) {
-        const content = String(event.content || '').trim();
-        if (event.type === 'typing_start') {
-            // 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 = '';
-            turn.finalText = '';
-            turn.thinkingSteps = [];
-            turn.toolCalls = [];
-            turn.buttonRows = [];
-            turn.statusLines = [];
-            turn.lastPatchedAtByMessageId = {};
-            return;
-        }
-        if (event.type === 'typing_stop') {
-            turn.processing = false;
-            return;
-        }
-        if (event.type === 'preview_start' || event.type === 'update_message') {
-            turn.previewText = content;
-            return;
-        }
-        if (event.type === 'status') {
-            if (content) {
-                this.pushUnique(turn.statusLines, content);
-            }
-            return;
-        }
-        if (event.type === 'buttons') {
-            turn.awaitingPermission = true;
-            turn.buttonRows = [];
-            if (this.mirrorPermissionStateInMainCard && content) {
-                this.pushUnique(turn.statusLines, `等待确认: ${content}`);
-            }
-            return;
-        }
-        if (!content) {
-            return;
-        }
-        if (content.startsWith('💭 ')) {
-            this.pushUnique(turn.thinkingSteps, content.slice(3).trim());
-            return;
-        }
-        if (content.startsWith('🔧 ')) {
-            this.pushUnique(turn.toolCalls, content.slice(3).trim());
-            return;
-        }
-        if (content.startsWith('⏳ ') || content.startsWith('📤 ')) {
-            this.pushUnique(turn.statusLines, content.slice(3).trim());
-            return;
-        }
-        turn.finalText = content;
-        turn.previewText = content;
-    }
-    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,
-            };
-        }
-        if (event.type === 'status') {
-            return this.renderProgressMessage(this.progressKey('status', event), content.startsWith('⏳ ') ? content : `⏳ ${content}`);
-        }
-        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,
-            };
-        }
-        if (event.type === 'typing_start' || event.type === 'typing_stop') {
-            return { key: 'noop', text: '', buttonRows: [], isFinal: false };
-        }
-        return {
-            key: 'noop',
-            text: '',
-            buttonRows: [],
-            isFinal: false,
-        };
-    }
-    renderProgressMessage(key, text) {
-        return {
-            key,
-            text,
-            buttonRows: [],
-            isFinal: false,
-        };
-    }
-    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 || '',
-            cardActionsEnabled
-                ? '也可以直接回复：`allow` / `allow all` / `deny`'
-                : '请直接回复：`allow` / `allow all` / `deny`',
-        ].filter(Boolean);
-        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: this.formatPermissionButtonLabel(button),
-                    data: (0, desktop_js_1.normalizePermissionResponse)(button.data) || button.data,
-                }))
-                : [])
-                .filter((row) => row.length > 0)
-            : [];
-        return {
-            text: sections.join('\n\n').trim(),
-            buttonRows,
-        };
-    }
-    renderPendingPairingCard(code) {
-        const lines = [
-            '**已收到消息**',
-            '当前账号还未授权接入这个工作区。',
-            '请在桌面端完成审批后再次发送消息。',
-        ];
-        if (code) {
-            lines.push(`配对码：\`${code}\``);
-        }
-        return lines.join('\n\n');
+        (0, runtime_state_js_1.consumeLarkBridgeEvent)(turn, event, {
+            mirrorPermissionStateInMainCard: this.mirrorPermissionStateInMainCard,
+        });
     }
-    async handleCardActionEvent(workspaceId, data) {
+    async handleCardActionEvent(workspaceId, instanceIdOrData, maybeData) {
+        const legacyCall = typeof instanceIdOrData === 'object';
+        const instanceId = legacyCall ? 'default' : instanceIdOrData;
+        const data = (legacyCall ? instanceIdOrData : maybeData) || {};
         try {
-            const payload = (data?.event && typeof data.event === 'object')
-                ? data.event
-                : data;
-            const value = payload?.action?.value;
-            if (!value || value.action !== 'permission_response') {
-                return;
-            }
-            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) {
+            const action = (0, cards_js_1.extractCardActionValue)(data);
+            if (!action) {
                 return;
             }
             const router = this.options.getWorkspaceRouter();
-            await router.sendThreadAction(threadId, response);
-            this.options.log?.(`localcore-lark processed card action for ${workspaceId}: ${response}`);
+            await this.markPermissionCardActionHandled(workspaceId, instanceId, data, action.event, action.value, action.response, action.threadId);
+            await router.sendThreadAction(action.threadId, action.response);
+            this.options.log?.(`localcore-lark processed card action for ${workspaceId}/${instanceId}: ${action.response}`);
         }
         catch (error) {
-            this.options.log?.(`localcore-lark card action failed for ${workspaceId}: ${error instanceof Error ? error.message : String(error)}`);
+            this.options.log?.(`localcore-lark card action failed for ${workspaceId}/${instanceId}: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
-    pushUnique(target, value) {
-        const normalized = value.trim();
-        if (!normalized) {
+    async markPermissionCardActionHandled(workspaceId, instanceId, rootPayload, payload, value, response, threadId) {
+        const state = this.resolveRuntimeState(workspaceId, instanceId).state;
+        if (!state?.client) {
             return;
         }
-        if (target[target.length - 1] === normalized) {
+        const sessionKey = String(value.session_key || '').trim();
+        const turn = sessionKey ? this.outboundTurns.get(sessionKey) : undefined;
+        const messageId = (0, cards_js_1.extractCardActionMessageId)(rootPayload, payload, value) || turn?.permissionMessageId;
+        if (!messageId) {
+            this.options.log?.(`localcore-lark could not find permission card message id for workspace=${workspaceId} sessionKey=${sessionKey || 'missing'}`);
             return;
         }
-        target.push(normalized);
-        if (target.length > 6) {
-            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';
+        try {
+            await this.patchTextCard(state, messageId, [
+                '**工具确认已处理**',
+                `已选择：${(0, cards_js_1.formatPermissionResponseLabel)(response)}`,
+                '等待代理继续执行...',
+            ].join('\n\n'), [], sessionKey || undefined, threadId);
+            if (turn) {
+                turn.awaitingPermission = false;
+                turn.buttonRows = [];
+            }
         }
-        if (response === 'allow') {
-            return 'primary';
+        catch (error) {
+            this.options.log?.(`localcore-lark failed to patch handled permission card ${messageId}: ${error instanceof Error ? error.message : String(error)}`);
         }
-        return index === 0 ? 'primary' : 'default';
-    }
-    buildPermissionSummary(turn, rawContent) {
-        const lastTool = turn.toolCalls[turn.toolCalls.length - 1] || '';
-        const [commandPart = '', reasonPart = ''] = lastTool.split(/\s+-\s+/, 2);
-        const compactContent = rawContent
-            .replace(/\s+/g, ' ')
-            .replace(/请选择一个选项继续执行。?/g, '')
-            .replace(/若按钮没有显示，请直接回复：?\s*allow all \/ allow \/ deny/gi, '')
-            .replace(/等待工具确认/gi, '')
-            .trim();
-        return {
-            command: commandPart.trim(),
-            reason: reasonPart.trim() || compactContent,
-        };
-    }
-    formatCompactToolLines(toolCalls) {
-        return toolCalls.slice(-2).map((line) => {
-            const compact = line.replace(/\s+/g, ' ').trim();
-            return compact.startsWith('Terminal') ? '• Terminal' : `• ${compact}`;
-        });
     }
-    async sendImmediateCard(workspaceId, chatId, text) {
-        const state = this.runtime.get(workspaceId);
+    async sendImmediateCard(workspaceId, chatId, text, instanceId) {
+        const state = this.resolveRuntimeState(workspaceId, instanceId).state;
         if (!state?.client || !state.connected) {
             this.options.log?.(`localcore-lark immediate card skipped because workspace is not connected: ${workspaceId}`);
             return '';
@@ -1235,8 +1217,8 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
             return '';
         }
     }
-    async addAcknowledgementReaction(workspaceId, messageId, turn) {
-        const state = this.runtime.get(workspaceId);
+    async addAcknowledgementReaction(workspaceId, messageId, turn, instanceId) {
+        const state = this.resolveRuntimeState(workspaceId, instanceId).state;
         if (!state?.client || !state.connected || !messageId) {
             return;
         }