@kafca/agentdock 0.1.43 → 0.1.44

package/dist-electron/tests/integration/lark-gateway.test.js

@@ -0,0 +1,1918 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_test_1 = __importDefault(require("node:test"));
+const strict_1 = __importDefault(require("node:assert/strict"));
+const node_fs_1 = require("node:fs");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const node_stream_1 = require("node:stream");
+const local_core_lark_gateway_js_1 = require("../../services/local-ai-core/src/channel/lark/local-core-lark-gateway.js");
+const runtime_state_js_1 = require("../../services/local-ai-core/src/channel/lark/runtime-state.js");
+function extractLarkCreatedMessage(request) {
+    const msgType = String(request.data?.msg_type || '');
+    const content = JSON.parse(String(request.data?.content || '{}'));
+    return {
+        msgType,
+        content,
+        text: extractLarkCreatedMessageText(msgType, content),
+    };
+}
+function extractLarkCreatedMessageText(msgType, content) {
+    if (msgType === 'interactive') {
+        return String(content.elements?.[0]?.content || content.body?.elements?.[0]?.content || '');
+    }
+    if (msgType === 'post') {
+        return (content.zh_cn?.content || [])
+            .map((line) => (Array.isArray(line) ? line : [])
+            .map((item) => {
+            return String(item?.text || item?.href || '');
+        })
+            .join(''))
+            .join('\n');
+    }
+    return String(content.text || '');
+}
+function findLarkPostMdText(content) {
+    for (const line of content.zh_cn?.content || []) {
+        for (const item of Array.isArray(line) ? line : []) {
+            if (item?.tag === 'md') {
+                return String(item.text || '');
+            }
+        }
+    }
+    return '';
+}
+(0, node_test_1.default)('lark bridge sends completed thought once before final answer', async () => {
+    const createdMessages = [];
+    const patchedCards = [];
+    const storedMessageIds = [];
+    const client = {
+        im: {
+            message: {
+                create: async (request) => {
+                    const messageId = `lark-msg-${createdMessages.length + 1}`;
+                    const message = extractLarkCreatedMessage(request);
+                    createdMessages.push({
+                        messageId,
+                        msgType: message.msgType,
+                        text: message.text,
+                        content: message.content,
+                    });
+                    return { data: { message_id: messageId } };
+                },
+                patch: async (request) => {
+                    const card = JSON.parse(String(request.data.content || '{}'));
+                    patchedCards.push({
+                        messageId: String(request.path.message_id || ''),
+                        text: String(card.elements?.[0]?.content || ''),
+                    });
+                },
+            },
+        },
+    };
+    const gateway = new local_core_lark_gateway_js_1.LocalCoreLarkGateway({
+        store: {
+            getPlatformThreadBinding: () => ({
+                workspace_id: 'default',
+                platform: 'lark',
+                chat_id: 'chat-1',
+                platform_user_id: 'user-1',
+                thread_id: 'thread-1',
+                last_platform_message_id: null,
+            }),
+            updatePlatformThreadMessageId: (_workspaceId, _chatId, _platformUserId, messageId) => {
+                storedMessageIds.push(messageId);
+            },
+        },
+        readConfig: async () => null,
+        getWorkspaceRouter: () => ({}),
+        eventBus: { emit: () => { }, on: () => () => { } },
+    });
+    const internals = gateway;
+    internals.runtime.set('default', {
+        workspaceId: 'default',
+        enabled: true,
+        status: 'running',
+        connected: true,
+        appId: 'app-1',
+        client,
+    });
+    internals.threadRouting.set('session:thread-1', {
+        workspaceId: 'default',
+        platformUserId: 'user-1',
+        chatId: 'chat-1',
+        threadId: 'thread-1',
+    });
+    await gateway.onBridgeEvent({
+        type: 'preview_start',
+        sessionKey: 'session:thread-1',
+        replyCtx: 'run-1',
+        previewHandle: 'thought-preview-1',
+        bridgeKind: 'thought',
+        content: '先理解问题',
+    });
+    await gateway.onBridgeEvent({
+        type: 'update_message',
+        sessionKey: 'session:thread-1',
+        replyCtx: 'run-1',
+        previewHandle: 'thought-preview-1',
+        bridgeKind: 'thought',
+        content: '先理解问题，再检查代码',
+    });
+    await gateway.onBridgeEvent({
+        type: 'reply',
+        sessionKey: 'session:thread-1',
+        replyCtx: 'run-1',
+        content: '最终回答',
+    });
+    strict_1.default.deepEqual(createdMessages.map((message) => message.msgType), ['interactive', 'post']);
+    strict_1.default.equal(createdMessages[0]?.text, '先理解问题，再检查代码');
+    strict_1.default.equal(createdMessages[1]?.text, '最终回答');
+    strict_1.default.equal(patchedCards.length, 0);
+    strict_1.default.deepEqual(storedMessageIds, ['lark-msg-2']);
+});
+(0, node_test_1.default)('lark bridge sends final reply as its own post message instead of streaming draft', async () => {
+    const createdMessages = [];
+    const patchedCards = [];
+    const storedMessageIds = [];
+    const client = {
+        im: {
+            message: {
+                create: async (request) => {
+                    const messageId = `lark-msg-${createdMessages.length + 1}`;
+                    const message = extractLarkCreatedMessage(request);
+                    createdMessages.push({
+                        messageId,
+                        msgType: message.msgType,
+                        text: message.text,
+                        content: message.content,
+                    });
+                    return { data: { message_id: messageId } };
+                },
+                patch: async (request) => {
+                    const card = JSON.parse(String(request.data.content || '{}'));
+                    patchedCards.push({
+                        messageId: String(request.path.message_id || ''),
+                        text: String(card.elements?.[0]?.content || ''),
+                    });
+                },
+            },
+        },
+    };
+    const gateway = new local_core_lark_gateway_js_1.LocalCoreLarkGateway({
+        store: {
+            getPlatformThreadBinding: () => ({
+                workspace_id: 'default',
+                platform: 'lark',
+                chat_id: 'chat-1',
+                platform_user_id: 'user-1',
+                thread_id: 'thread-1',
+                last_platform_message_id: null,
+            }),
+            updatePlatformThreadMessageId: (_workspaceId, _chatId, _platformUserId, messageId) => {
+                storedMessageIds.push(messageId);
+            },
+        },
+        readConfig: async () => null,
+        getWorkspaceRouter: () => ({}),
+        eventBus: { emit: () => { }, on: () => () => { } },
+    });
+    const internals = gateway;
+    internals.runtime.set('default', {
+        workspaceId: 'default',
+        enabled: true,
+        status: 'running',
+        connected: true,
+        appId: 'app-1',
+        client,
+    });
+    internals.threadRouting.set('session:thread-1', {
+        workspaceId: 'default',
+        platformUserId: 'user-1',
+        chatId: 'chat-1',
+        threadId: 'thread-1',
+    });
+    await gateway.onBridgeEvent({
+        type: 'update_message',
+        sessionKey: 'session:thread-1',
+        replyCtx: 'run-1',
+        content: '流式中的最终回答草稿',
+    });
+    await gateway.onBridgeEvent({
+        type: 'reply',
+        sessionKey: 'session:thread-1',
+        replyCtx: 'run-1',
+        content: '真正最终回答',
+    });
+    strict_1.default.deepEqual(createdMessages.map((message) => message.msgType), ['post']);
+    strict_1.default.deepEqual(createdMessages.map((message) => message.text), ['真正最终回答']);
+    strict_1.default.deepEqual(patchedCards, []);
+    strict_1.default.deepEqual(storedMessageIds, ['lark-msg-1']);
+});
+(0, node_test_1.default)('lark bridge sends completed assistant segments as separate non-final messages', async () => {
+    const createdMessages = [];
+    const patchedCards = [];
+    const storedMessageIds = [];
+    const client = {
+        im: {
+            message: {
+                create: async (request) => {
+                    const messageId = `lark-msg-${createdMessages.length + 1}`;
+                    const message = extractLarkCreatedMessage(request);
+                    createdMessages.push({
+                        messageId,
+                        msgType: message.msgType,
+                        text: message.text,
+                        content: message.content,
+                    });
+                    return { data: { message_id: messageId } };
+                },
+                patch: async (request) => {
+                    const card = JSON.parse(String(request.data.content || '{}'));
+                    patchedCards.push({
+                        messageId: String(request.path.message_id || ''),
+                        text: String(card.elements?.[0]?.content || ''),
+                    });
+                },
+            },
+        },
+    };
+    const gateway = new local_core_lark_gateway_js_1.LocalCoreLarkGateway({
+        store: {
+            getPlatformThreadBinding: () => ({
+                workspace_id: 'default',
+                platform: 'lark',
+                chat_id: 'chat-1',
+                platform_user_id: 'user-1',
+                thread_id: 'thread-1',
+                last_platform_message_id: null,
+            }),
+            updatePlatformThreadMessageId: (_workspaceId, _chatId, _platformUserId, messageId) => {
+                storedMessageIds.push(messageId);
+            },
+        },
+        readConfig: async () => null,
+        getWorkspaceRouter: () => ({}),
+        eventBus: { emit: () => { }, on: () => () => { } },
+    });
+    const internals = gateway;
+    internals.runtime.set('default', {
+        workspaceId: 'default',
+        enabled: true,
+        status: 'running',
+        connected: true,
+        appId: 'app-1',
+        client,
+    });
+    internals.threadRouting.set('session:thread-1', {
+        workspaceId: 'default',
+        platformUserId: 'user-1',
+        chatId: 'chat-1',
+        threadId: 'thread-1',
+    });
+    await gateway.onBridgeEvent({
+        type: 'reply',
+        sessionKey: 'session:thread-1',
+        replyCtx: 'run-1',
+        messageId: 'run-1-assistant-1',
+        bridgeKind: 'assistant',
+        content: '我先检查一下',
+    });
+    await gateway.onBridgeEvent({
+        type: 'reply',
+        sessionKey: 'session:thread-1',
+        replyCtx: 'run-1',
+        content: '最终回答',
+    });
+    strict_1.default.deepEqual(createdMessages.map((message) => message.msgType), ['post', 'post']);
+    strict_1.default.deepEqual(createdMessages.map((message) => message.text), ['我先检查一下', '最终回答']);
+    strict_1.default.deepEqual(patchedCards, []);
+    strict_1.default.deepEqual(storedMessageIds, ['lark-msg-2']);
+});
+(0, node_test_1.default)('lark bridge creates final replies without patching prior final messages', async () => {
+    const createdMessages = [];
+    const patchedCards = [];
+    const client = {
+        im: {
+            message: {
+                create: async (request) => {
+                    const messageId = `lark-msg-${createdMessages.length + 1}`;
+                    const message = extractLarkCreatedMessage(request);
+                    createdMessages.push({
+                        messageId,
+                        msgType: message.msgType,
+                        text: message.text,
+                        content: message.content,
+                    });
+                    return { data: { message_id: messageId } };
+                },
+                patch: async (request) => {
+                    const card = JSON.parse(String(request.data.content || '{}'));
+                    patchedCards.push({
+                        messageId: String(request.path.message_id || ''),
+                        text: String(card.elements?.[0]?.content || ''),
+                    });
+                },
+            },
+        },
+    };
+    const gateway = new local_core_lark_gateway_js_1.LocalCoreLarkGateway({
+        store: {
+            getPlatformThreadBinding: () => ({
+                workspace_id: 'default',
+                platform: 'lark',
+                chat_id: 'chat-1',
+                platform_user_id: 'user-1',
+                thread_id: 'thread-1',
+                last_platform_message_id: null,
+            }),
+            updatePlatformThreadMessageId: () => { },
+        },
+        readConfig: async () => null,
+        getWorkspaceRouter: () => ({}),
+        eventBus: { emit: () => { }, on: () => () => { } },
+    });
+    const internals = gateway;
+    internals.runtime.set('default', {
+        workspaceId: 'default',
+        enabled: true,
+        status: 'running',
+        connected: true,
+        appId: 'app-1',
+        client,
+    });
+    internals.threadRouting.set('session:thread-1', {
+        workspaceId: 'default',
+        platformUserId: 'user-1',
+        chatId: 'chat-1',
+        threadId: 'thread-1',
+    });
+    await gateway.onBridgeEvent({
+        type: 'reply',
+        sessionKey: 'session:thread-1',
+        replyCtx: 'run-1',
+        content: 'first final',
+    });
+    await gateway.onBridgeEvent({
+        type: 'reply',
+        sessionKey: 'session:thread-1',
+        replyCtx: 'run-2',
+        content: 'second final',
+    });
+    strict_1.default.deepEqual(createdMessages.map((message) => message.msgType), ['post', 'post']);
+    strict_1.default.deepEqual(createdMessages.map((message) => message.text), ['first final', 'second final']);
+    strict_1.default.deepEqual(patchedCards, []);
+});
+(0, node_test_1.default)('lark bridge sends tool and final as separate post messages without patching tool progress', async () => {
+    const createdMessages = [];
+    const patchedCards = [];
+    const storedMessageIds = [];
+    const client = {
+        im: {
+            message: {
+                create: async (request) => {
+                    const messageId = `lark-msg-${createdMessages.length + 1}`;
+                    const message = extractLarkCreatedMessage(request);
+                    createdMessages.push({
+                        messageId,
+                        msgType: message.msgType,
+                        text: message.text,
+                        content: message.content,
+                    });
+                    return { data: { message_id: messageId } };
+                },
+                patch: async (request) => {
+                    const card = JSON.parse(String(request.data.content || '{}'));
+                    patchedCards.push({
+                        messageId: String(request.path.message_id || ''),
+                        text: String(card.elements?.[0]?.content || ''),
+                    });
+                },
+            },
+        },
+    };
+    const gateway = new local_core_lark_gateway_js_1.LocalCoreLarkGateway({
+        store: {
+            getPlatformThreadBinding: () => ({
+                workspace_id: 'default',
+                platform: 'lark',
+                chat_id: 'chat-1',
+                platform_user_id: 'user-1',
+                thread_id: 'thread-1',
+                last_platform_message_id: null,
+            }),
+            updatePlatformThreadMessageId: (_workspaceId, _chatId, _platformUserId, messageId) => {
+                storedMessageIds.push(messageId);
+            },
+        },
+        readConfig: async () => null,
+        getWorkspaceRouter: () => ({}),
+        eventBus: { emit: () => { }, on: () => () => { } },
+    });
+    const internals = gateway;
+    internals.runtime.set('default', {
+        workspaceId: 'default',
+        enabled: true,
+        status: 'running',
+        connected: true,
+        appId: 'app-1',
+        client,
+    });
+    internals.threadRouting.set('session:thread-1', {
+        workspaceId: 'default',
+        platformUserId: 'user-1',
+        chatId: 'chat-1',
+        threadId: 'thread-1',
+    });
+    await gateway.onBridgeEvent({
+        type: 'update_message',
+        sessionKey: 'session:thread-1',
+        replyCtx: 'run-1',
+        content: '好的，文件存在，现在发送给你：已',
+    });
+    await gateway.onBridgeEvent({
+        type: 'reply',
+        sessionKey: 'session:thread-1',
+        replyCtx: 'run-1',
+        messageId: 'tool-1',
+        bridgeKind: 'tool',
+        content: 'bash completed',
+        toolCall: {
+            id: 'tool-1',
+            name: 'bash',
+            status: 'completed',
+            output: 'Sent file CLAUDE.md to chat-1: msg-file-1',
+        },
+    });
+    await gateway.onBridgeEvent({
+        type: 'reply',
+        sessionKey: 'session:thread-1',
+        replyCtx: 'run-1',
+        content: '好的，文件存在，现在发送给你：已发送！`CLAUDE.md` 文件已经发出去了，请查收',
+    });
+    strict_1.default.deepEqual(createdMessages.map((message) => message.msgType), ['post', 'post']);
+    strict_1.default.deepEqual(createdMessages.map((message) => message.text), [
+        '🔧 bash',
+        '好的，文件存在，现在发送给你：已发送！`CLAUDE.md` 文件已经发出去了，请查收',
+    ]);
+    strict_1.default.deepEqual(patchedCards, []);
+    strict_1.default.deepEqual(storedMessageIds, ['lark-msg-2']);
+});
+(0, node_test_1.default)('lark bridge flushes interleaved thought segments before tools and final', async () => {
+    const createdMessages = [];
+    const patchedCards = [];
+    const storedMessageIds = [];
+    const client = {
+        im: {
+            message: {
+                create: async (request) => {
+                    const messageId = `lark-msg-${createdMessages.length + 1}`;
+                    const message = extractLarkCreatedMessage(request);
+                    createdMessages.push({
+                        messageId,
+                        msgType: message.msgType,
+                        text: message.text,
+                        content: message.content,
+                    });
+                    return { data: { message_id: messageId } };
+                },
+                patch: async (request) => {
+                    const card = JSON.parse(String(request.data.content || '{}'));
+                    patchedCards.push({
+                        messageId: String(request.path.message_id || ''),
+                        text: String(card.elements?.[0]?.content || ''),
+                    });
+                },
+            },
+        },
+    };
+    const gateway = new local_core_lark_gateway_js_1.LocalCoreLarkGateway({
+        store: {
+            getPlatformThreadBinding: () => ({
+                workspace_id: 'default',
+                platform: 'lark',
+                chat_id: 'chat-1',
+                platform_user_id: 'user-1',
+                thread_id: 'thread-1',
+                last_platform_message_id: 'old-message',
+            }),
+            updatePlatformThreadMessageId: (_workspaceId, _chatId, _platformUserId, messageId) => {
+                storedMessageIds.push(messageId);
+            },
+        },
+        readConfig: async () => null,
+        getWorkspaceRouter: () => ({}),
+        eventBus: { emit: () => { }, on: () => () => { } },
+    });
+    const internals = gateway;
+    internals.runtime.set('default', {
+        workspaceId: 'default',
+        enabled: true,
+        status: 'running',
+        connected: true,
+        appId: 'app-1',
+        client,
+    });
+    internals.threadRouting.set('session:thread-1', {
+        workspaceId: 'default',
+        platformUserId: 'user-1',
+        chatId: 'chat-1',
+        threadId: 'thread-1',
+    });
+    await gateway.onBridgeEvent({
+        type: 'preview_start',
+        sessionKey: 'session:thread-1',
+        replyCtx: 'run-1',
+        previewHandle: 'thought-preview-1',
+        bridgeKind: 'thought',
+        content: '先理解',
+    });
+    await gateway.onBridgeEvent({
+        type: 'update_message',
+        sessionKey: 'session:thread-1',
+        replyCtx: 'run-1',
+        previewHandle: 'thought-preview-1',
+        bridgeKind: 'thought',
+        content: '先理解用户需求',
+    });
+    await gateway.onBridgeEvent({
+        type: 'reply',
+        sessionKey: 'session:thread-1',
+        replyCtx: 'run-1',
+        messageId: 'run-1-tool-1',
+        bridgeKind: 'tool',
+        content: 'Terminal running',
+        toolCall: {
+            id: 'call-1',
+            name: 'Terminal',
+            status: 'running',
+            input: { command: 'uname -a', description: 'Get system info' },
+            output: '',
+        },
+    });
+    await gateway.onBridgeEvent({
+        type: 'reply',
+        sessionKey: 'session:thread-1',
+        replyCtx: 'run-1',
+        messageId: 'run-1-tool-1',
+        bridgeKind: 'tool',
+        content: 'Terminal completed',
+        toolCall: {
+            id: 'call-1',
+            name: 'Terminal',
+            status: 'completed',
+            input: { command: 'uname -a', description: 'Get system info' },
+            output: 'Linux',
+        },
+    });
+    await gateway.onBridgeEvent({
+        type: 'update_message',
+        sessionKey: 'session:thread-1',
+        replyCtx: 'run-1',
+        previewHandle: 'thought-preview-1',
+        bridgeKind: 'thought',
+        content: '看到了 Linux',
+    });
+    await gateway.onBridgeEvent({
+        type: 'reply',
+        sessionKey: 'session:thread-1',
+        replyCtx: 'run-1',
+        content: '最终回答',
+    });
+    strict_1.default.deepEqual(createdMessages.map((message) => message.msgType), ['interactive', 'post', 'interactive', 'post']);
+    strict_1.default.deepEqual(createdMessages.map((message) => message.text), [
+        '先理解用户需求',
+        '🔧 Terminal\n\n```json\n{\n  "command": "uname -a",\n  "description": "Get system info"\n}\n```',
+        '看到了 Linux',
+        '最终回答',
+    ]);
+    strict_1.default.equal(findLarkPostMdText(createdMessages[1]?.content), '🔧 Terminal\n\n```json\n{\n  "command": "uname -a",\n  "description": "Get system info"\n}\n```');
+    strict_1.default.deepEqual(patchedCards, []);
+    strict_1.default.deepEqual(storedMessageIds, ['lark-msg-4']);
+});
+(0, node_test_1.default)('lark bridge does not stream thought updates before completion', async () => {
+    const createdCards = [];
+    const patchedCards = [];
+    const client = {
+        im: {
+            message: {
+                create: async (request) => {
+                    const messageId = `lark-msg-${createdCards.length + 1}`;
+                    const card = JSON.parse(String(request.data.content || '{}'));
+                    createdCards.push({
+                        messageId,
+                        text: String(card.elements?.[0]?.content || ''),
+                    });
+                    return { data: { message_id: messageId } };
+                },
+                patch: async (request) => {
+                    const card = JSON.parse(String(request.data.content || '{}'));
+                    patchedCards.push({
+                        messageId: String(request.path.message_id || ''),
+                        text: String(card.elements?.[0]?.content || ''),
+                    });
+                },
+            },
+        },
+    };
+    const gateway = new local_core_lark_gateway_js_1.LocalCoreLarkGateway({
+        store: {
+            getPlatformThreadBinding: () => ({
+                workspace_id: 'default',
+                platform: 'lark',
+                chat_id: 'chat-1',
+                platform_user_id: 'user-1',
+                thread_id: 'thread-1',
+                last_platform_message_id: null,
+            }),
+            updatePlatformThreadMessageId: () => { },
+        },
+        readConfig: async () => null,
+        getWorkspaceRouter: () => ({}),
+        eventBus: { emit: () => { }, on: () => () => { } },
+    });
+    const internals = gateway;
+    internals.runtime.set('default', {
+        workspaceId: 'default',
+        enabled: true,
+        status: 'running',
+        connected: true,
+        appId: 'app-1',
+        client,
+    });
+    internals.threadRouting.set('session:thread-1', {
+        workspaceId: 'default',
+        platformUserId: 'user-1',
+        chatId: 'chat-1',
+        threadId: 'thread-1',
+    });
+    await gateway.onBridgeEvent({
+        type: 'typing_start',
+        sessionKey: 'session:thread-1',
+        replyCtx: 'run-1',
+    });
+    await gateway.onBridgeEvent({
+        type: 'preview_start',
+        sessionKey: 'session:thread-1',
+        replyCtx: 'run-1',
+        previewHandle: 'thought-preview-1',
+        bridgeKind: 'thought',
+        content: 'The user',
+    });
+    await gateway.onBridgeEvent({
+        type: 'update_message',
+        sessionKey: 'session:thread-1',
+        replyCtx: 'run-1',
+        previewHandle: 'thought-preview-1',
+        bridgeKind: 'thought',
+        content: 'The user sent a short casual message.',
+    });
+    await gateway.onBridgeEvent({
+        type: 'update_message',
+        sessionKey: 'session:thread-1',
+        replyCtx: 'run-1',
+        previewHandle: 'thought-preview-1',
+        bridgeKind: 'thought',
+        content: 'The user sent a short casual message. I should reply briefly.',
+    });
+    await gateway.onBridgeEvent({
+        type: 'typing_stop',
+        sessionKey: 'session:thread-1',
+        replyCtx: 'run-1',
+    });
+    strict_1.default.deepEqual(createdCards.map((card) => card.text), ['The user sent a short casual message. I should reply briefly.']);
+    strict_1.default.deepEqual(patchedCards.map((card) => card.text), []);
+    strict_1.default.ok(!createdCards.some((card) => /处理中|正在思考/.test(card.text)));
+});
+(0, node_test_1.default)('lark permission requests render as clickable card buttons', async () => {
+    const createdCards = [];
+    const patchedCards = [];
+    const threadActions = [];
+    const client = {
+        im: {
+            message: {
+                create: async (request) => {
+                    createdCards.push(JSON.parse(String(request.data.content || '{}')));
+                    return { data: { message_id: 'permission-msg-1' } };
+                },
+                patch: async (request) => {
+                    patchedCards.push({
+                        messageId: request.path?.message_id,
+                        card: JSON.parse(String(request.data.content || '{}')),
+                    });
+                },
+            },
+        },
+    };
+    const gateway = new local_core_lark_gateway_js_1.LocalCoreLarkGateway({
+        store: {
+            getPlatformThreadBinding: () => ({
+                workspace_id: 'default',
+                platform: 'lark',
+                chat_id: 'chat-1',
+                platform_user_id: 'user-1',
+                thread_id: 'thread-1',
+                last_platform_message_id: null,
+            }),
+        },
+        readConfig: async () => null,
+        getWorkspaceRouter: () => ({
+            sendThreadAction: async (threadId, action) => {
+                threadActions.push({ threadId, action });
+                return { runId: 'run-1' };
+            },
+        }),
+        eventBus: { emit: () => { }, on: () => () => { } },
+    });
+    const internals = gateway;
+    internals.runtime.set('default', {
+        workspaceId: 'default',
+        enabled: true,
+        status: 'running',
+        connected: true,
+        appId: 'app-1',
+        cardActionsEnabled: true,
+        client,
+    });
+    internals.threadRouting.set('session:thread-1', {
+        workspaceId: 'default',
+        platformUserId: 'user-1',
+        chatId: 'chat-1',
+        threadId: 'thread-1',
+    });
+    await gateway.onBridgeEvent({
+        type: 'buttons',
+        sessionKey: 'session:thread-1',
+        replyCtx: 'run-1',
+        content: [
+            '等待工具确认',
+            '',
+            'Terminal',
+            '',
+            'parameters:',
+            '{"command":"ls"}',
+            '',
+            '请选择一个选项继续执行。',
+        ].join('\n'),
+        buttonRows: [[
+                { text: 'allow', data: 'allow' },
+                { text: 'allow all', data: 'allow all' },
+                { text: 'deny', data: 'deny' },
+            ]],
+    });
+    const actionElement = createdCards[0]?.elements?.find((element) => element.tag === 'action');
+    strict_1.default.equal(createdCards.length, 1);
+    strict_1.default.match(createdCards[0]?.elements?.[0]?.content || '', /需要工具确认/);
+    strict_1.default.deepEqual(actionElement?.actions?.map((action) => ({
+        label: action.text?.content,
+        type: action.type,
+        response: action.value?.response,
+        threadId: action.value?.thread_id,
+    })), [
+        { label: '允许一次', type: 'primary', response: 'allow', threadId: 'thread-1' },
+        { label: '始终允许', type: 'default', response: 'allow all', threadId: 'thread-1' },
+        { label: '拒绝', type: 'danger', response: 'deny', threadId: 'thread-1' },
+    ]);
+    await internals.handleCardActionEvent('default', {
+        event: {
+            action: {
+                value: {
+                    action: 'permission_response',
+                    response: 'allow all',
+                    thread_id: 'thread-1',
+                    session_key: 'session:thread-1',
+                },
+            },
+            context: {
+                open_message_id: 'permission-msg-1',
+            },
+        },
+    });
+    strict_1.default.deepEqual(threadActions, [
+        { threadId: 'thread-1', action: 'allow all' },
+    ]);
+    strict_1.default.equal(patchedCards.length, 1);
+    strict_1.default.equal(patchedCards[0]?.messageId, 'permission-msg-1');
+    strict_1.default.match(patchedCards[0]?.card?.elements?.[0]?.content || '', /工具确认已处理/);
+    strict_1.default.equal(patchedCards[0]?.card?.elements?.some((element) => element.tag === 'action'), false);
+});
+(0, node_test_1.default)('lark allow all card action preserves the final reply after tool execution', async () => {
+    const createdMessages = [];
+    const patchedCards = [];
+    let nextMessageId = 1;
+    let gateway;
+    const client = {
+        im: {
+            message: {
+                create: async (request) => {
+                    const messageId = `card-${nextMessageId++}`;
+                    const message = extractLarkCreatedMessage(request);
+                    createdMessages.push({
+                        messageId,
+                        msgType: message.msgType,
+                        text: message.text,
+                        content: message.content,
+                    });
+                    return { data: { message_id: messageId } };
+                },
+                patch: async (request) => {
+                    patchedCards.push({
+                        messageId: request.path?.message_id,
+                        card: JSON.parse(String(request.data.content || '{}')),
+                    });
+                },
+            },
+        },
+    };
+    gateway = new local_core_lark_gateway_js_1.LocalCoreLarkGateway({
+        store: {
+            getPlatformThreadBinding: () => ({
+                workspace_id: 'default',
+                platform: 'lark',
+                chat_id: 'chat-1',
+                platform_user_id: 'user-1',
+                thread_id: 'thread-1',
+                last_platform_message_id: null,
+            }),
+            clearPlatformThreadMessageId: () => { },
+            updatePlatformThreadMessageId: () => { },
+        },
+        readConfig: async () => null,
+        getWorkspaceRouter: () => ({
+            sendThreadAction: async (threadId, action) => {
+                strict_1.default.equal(threadId, 'thread-1');
+                strict_1.default.equal(action, 'allow all');
+                await gateway.onBridgeEvent({
+                    type: 'typing_start',
+                    sessionKey: 'session:thread-1',
+                    replyCtx: 'run-1',
+                });
+                await gateway.onBridgeEvent({
+                    type: 'reply',
+                    sessionKey: 'session:thread-1',
+                    replyCtx: 'run-1',
+                    content: '桌面文件列表：AI进展报告_2026年4月.md',
+                });
+                return { runId: 'run-1' };
+            },
+        }),
+        eventBus: { emit: () => { }, on: () => () => { } },
+    });
+    const internals = gateway;
+    internals.runtime.set('default', {
+        workspaceId: 'default',
+        enabled: true,
+        status: 'running',
+        connected: true,
+        appId: 'app-1',
+        cardActionsEnabled: true,
+        client,
+    });
+    internals.threadRouting.set('session:thread-1', {
+        workspaceId: 'default',
+        platformUserId: 'user-1',
+        chatId: 'chat-1',
+        threadId: 'thread-1',
+    });
+    internals.outboundTurns.set('session:thread-1', {
+        sessionKey: 'session:thread-1',
+        progressMessageIds: {},
+        permissionMessageId: 'permission-msg-1',
+        awaitingPermission: true,
+        processing: true,
+        previewText: '',
+        finalText: '',
+        thinkingSteps: [],
+        thoughtSegmentSequence: 0,
+        toolCalls: [],
+        statusLines: [],
+        buttonRows: [[{ text: '始终允许', data: 'allow all' }]],
+        lastPatchedAt: 0,
+        lastPatchedAtByMessageId: {},
+    });
+    await internals.handleCardActionEvent('default', {
+        event: {
+            action: {
+                value: {
+                    action: 'permission_response',
+                    response: 'allow all',
+                    thread_id: 'thread-1',
+                    session_key: 'session:thread-1',
+                },
+            },
+            context: {
+                open_message_id: 'permission-msg-1',
+            },
+        },
+    });
+    strict_1.default.equal(patchedCards[0]?.messageId, 'permission-msg-1');
+    strict_1.default.match(patchedCards[0]?.card?.elements?.[0]?.content || '', /工具确认已处理/);
+    strict_1.default.equal(createdMessages.length, 1);
+    strict_1.default.equal(createdMessages[0]?.msgType, 'post');
+    strict_1.default.match(createdMessages[0]?.text || '', /桌面文件列表/);
+});
+(0, node_test_1.default)('lark channel sends tool name and parameters once without streaming output', async () => {
+    const createdMessages = [];
+    const patchedCards = [];
+    const client = {
+        im: {
+            message: {
+                create: async (request) => {
+                    createdMessages.push(extractLarkCreatedMessage(request));
+                    return { data: { message_id: 'tool-msg-1' } };
+                },
+                patch: async (request) => {
+                    patchedCards.push(JSON.parse(String(request.data.content || '{}')));
+                },
+            },
+        },
+    };
+    const gateway = new local_core_lark_gateway_js_1.LocalCoreLarkGateway({
+        store: {
+            getPlatformThreadBinding: () => ({
+                workspace_id: 'default',
+                platform: 'lark',
+                chat_id: 'chat-1',
+                platform_user_id: 'user-1',
+                thread_id: 'thread-1',
+                last_platform_message_id: null,
+            }),
+        },
+        readConfig: async () => null,
+        getWorkspaceRouter: () => ({}),
+        eventBus: { emit: () => { }, on: () => () => { } },
+    });
+    const internals = gateway;
+    internals.runtime.set('default', {
+        workspaceId: 'default',
+        enabled: true,
+        status: 'running',
+        connected: true,
+        appId: 'app-1',
+        client,
+    });
+    internals.threadRouting.set('session:thread-1', {
+        workspaceId: 'default',
+        platformUserId: 'user-1',
+        chatId: 'chat-1',
+        threadId: 'thread-1',
+    });
+    await gateway.onBridgeEvent({
+        type: 'reply',
+        sessionKey: 'session:thread-1',
+        replyCtx: 'run-1',
+        messageId: 'tool-1',
+        bridgeKind: 'tool',
+        content: 'Terminal running',
+        toolCall: {
+            id: 'tool-1',
+            name: 'Terminal',
+            status: 'running',
+            input: { command: 'ls ~/Desktop' },
+            output: '',
+        },
+    });
+    await gateway.onBridgeEvent({
+        type: 'reply',
+        sessionKey: 'session:thread-1',
+        replyCtx: 'run-1',
+        messageId: 'tool-1',
+        bridgeKind: 'tool',
+        content: 'Terminal completed',
+        toolCall: {
+            id: 'tool-1',
+            name: 'Terminal',
+            status: 'completed',
+            input: { command: 'ls ~/Desktop' },
+            output: 'secret terminal output',
+        },
+    });
+    const text = createdMessages[0]?.text || '';
+    strict_1.default.equal(createdMessages[0]?.msgType, 'post');
+    strict_1.default.match(text, /🔧 Terminal/);
+    strict_1.default.match(text, /```json\n{\n  "command": "ls ~\/Desktop"\n}\n```/);
+    strict_1.default.doesNotMatch(text, /参数/);
+    strict_1.default.equal(findLarkPostMdText(createdMessages[0]?.content), '🔧 Terminal\n\n```json\n{\n  "command": "ls ~/Desktop"\n}\n```');
+    strict_1.default.equal(patchedCards.length, 0);
+    strict_1.default.doesNotMatch(text, /completed/);
+    strict_1.default.doesNotMatch(text, /secret terminal output/);
+});
+(0, node_test_1.default)('lark card action message id can be extracted from full callback payload', async () => {
+    const patchedCards = [];
+    const threadActions = [];
+    const client = {
+        im: {
+            message: {
+                patch: async (request) => {
+                    patchedCards.push({
+                        messageId: request.path?.message_id,
+                        card: JSON.parse(String(request.data.content || '{}')),
+                    });
+                },
+            },
+        },
+    };
+    const gateway = new local_core_lark_gateway_js_1.LocalCoreLarkGateway({
+        store: {},
+        readConfig: async () => null,
+        getWorkspaceRouter: () => ({
+            sendThreadAction: async (threadId, action) => {
+                threadActions.push({ threadId, action });
+                return { runId: 'run-1' };
+            },
+        }),
+        eventBus: { emit: () => { }, on: () => () => { } },
+    });
+    const internals = gateway;
+    internals.runtime.set('default', {
+        workspaceId: 'default',
+        enabled: true,
+        status: 'running',
+        connected: true,
+        appId: 'app-1',
+        client,
+    });
+    await internals.handleCardActionEvent('default', {
+        schema: '2.0',
+        event: {
+            action: {
+                value: {
+                    action: 'permission_response',
+                    response: 'allow',
+                    thread_id: 'thread-1',
+                },
+            },
+        },
+        event_context: {
+            open_message_id: 'permission-msg-nested',
+        },
+    });
+    strict_1.default.deepEqual(threadActions, [
+        { threadId: 'thread-1', action: 'allow' },
+    ]);
+    strict_1.default.equal(patchedCards[0]?.messageId, 'permission-msg-nested');
+    strict_1.default.equal(patchedCards[0]?.card?.elements?.some((element) => element.tag === 'action'), false);
+});
+(0, node_test_1.default)('lark permission requests fall back to text commands when card actions are disabled', async () => {
+    const createdCards = [];
+    const gateway = new local_core_lark_gateway_js_1.LocalCoreLarkGateway({
+        store: {
+            getPlatformThreadBinding: () => ({
+                workspace_id: 'default',
+                platform: 'lark',
+                chat_id: 'chat-1',
+                platform_user_id: 'user-1',
+                thread_id: 'thread-1',
+                last_platform_message_id: null,
+            }),
+        },
+        readConfig: async () => null,
+        getWorkspaceRouter: () => ({}),
+        eventBus: { emit: () => { }, on: () => () => { } },
+    });
+    const internals = gateway;
+    internals.runtime.set('default', {
+        workspaceId: 'default',
+        enabled: true,
+        status: 'running',
+        connected: true,
+        appId: 'app-1',
+        cardActionsEnabled: false,
+        client: {
+            im: {
+                message: {
+                    create: async (request) => {
+                        createdCards.push(JSON.parse(String(request.data.content || '{}')));
+                        return { data: { message_id: 'permission-msg-1' } };
+                    },
+                    patch: async () => { },
+                },
+            },
+        },
+    });
+    internals.threadRouting.set('session:thread-1', {
+        workspaceId: 'default',
+        platformUserId: 'user-1',
+        chatId: 'chat-1',
+        threadId: 'thread-1',
+    });
+    await gateway.onBridgeEvent({
+        type: 'buttons',
+        sessionKey: 'session:thread-1',
+        replyCtx: 'run-1',
+        content: '等待工具确认\n\nTerminal\n\n请选择一个选项继续执行。',
+        buttonRows: [[
+                { text: 'allow', data: 'allow' },
+                { text: 'deny', data: 'deny' },
+            ]],
+    });
+    strict_1.default.equal(createdCards.length, 1);
+    strict_1.default.match(createdCards[0]?.elements?.[0]?.content || '', /请直接回复/);
+    strict_1.default.equal(createdCards[0]?.elements?.some((element) => element.tag === 'action'), false);
+});
+(0, node_test_1.default)('lark image messages are downloaded and forwarded as generic channel image parts', async () => {
+    const sentMessages = [];
+    const pngBytes = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
+    const client = {
+        im: {
+            messageResource: {
+                get: async (request) => {
+                    strict_1.default.equal(request.path.message_id, 'msg-image-1');
+                    strict_1.default.equal(request.path.file_key, 'img-key-1');
+                    strict_1.default.equal(request.params.type, 'image');
+                    return {
+                        headers: { 'content-type': 'image/png' },
+                        getReadableStream: () => node_stream_1.Readable.from([pngBytes]),
+                    };
+                },
+            },
+            messageReaction: {
+                create: async () => ({ data: { reaction_id: 'reaction-1' } }),
+            },
+        },
+    };
+    const gateway = new local_core_lark_gateway_js_1.LocalCoreLarkGateway({
+        store: {
+            expirePendingPairings: () => { },
+            getAuthorizedUser: () => ({
+                id: 'auth-1',
+                workspace_id: 'default',
+                platform: 'lark',
+                platform_user_id: 'user-1',
+                chat_id: 'chat-1',
+                display_name: 'User',
+                thread_id: 'thread-1',
+            }),
+            getPlatformThreadBinding: () => ({
+                workspace_id: 'default',
+                platform: 'lark',
+                chat_id: 'chat-1',
+                platform_user_id: 'user-1',
+                thread_id: 'thread-1',
+                last_platform_message_id: null,
+            }),
+            getLatestRunForThread: () => null,
+            clearPlatformThreadMessageId: () => { },
+        },
+        readConfig: async () => ({
+            projects: [{
+                    name: 'default',
+                    root: '/tmp/project',
+                    platforms: [{
+                            type: 'lark',
+                            options: {
+                                app_id: 'app-1',
+                                app_secret: 'secret-1',
+                            },
+                        }],
+                }],
+        }),
+        getWorkspaceRouter: () => ({
+            getThreadSessionKey: (threadId) => `session:${threadId}`,
+            sendThreadMessage: async (threadId, content) => {
+                sentMessages.push({ threadId, content });
+                return { runId: 'run-1' };
+            },
+        }),
+        eventBus: { emit: () => { }, on: () => () => { } },
+    });
+    const internals = gateway;
+    internals.runtime.set('default', {
+        workspaceId: 'default',
+        enabled: true,
+        status: 'running',
+        connected: true,
+        appId: 'app-1',
+        client,
+    });
+    await internals.handleMessageEvent('default', {
+        event: {
+            sender: {
+                sender_id: { user_id: 'user-1' },
+            },
+            message: {
+                message_id: 'msg-image-1',
+                message_type: 'image',
+                chat_id: 'chat-1',
+                content: JSON.stringify({ image_key: 'img-key-1' }),
+            },
+        },
+    });
+    strict_1.default.equal(sentMessages.length, 1);
+    strict_1.default.equal(sentMessages[0]?.threadId, 'thread-1');
+    strict_1.default.match(sentMessages[0]?.content?.displayText, /\[User Message\]\n\[Image\]\n\[\/User Message\]/);
+    strict_1.default.deepEqual(sentMessages[0]?.content?.contentParts?.map((part) => part.type), ['text', 'image']);
+    strict_1.default.equal(sentMessages[0]?.content?.contentParts?.[1]?.mimeType, 'image/png');
+    strict_1.default.equal(sentMessages[0]?.content?.contentParts?.[1]?.data, pngBytes.toString('base64'));
+});
+(0, node_test_1.default)('lark file messages are downloaded and forwarded as generic channel file parts', async () => {
+    const sentMessages = [];
+    const fileBytes = Buffer.from('file content');
+    const client = {
+        im: {
+            messageResource: {
+                get: async (request) => {
+                    strict_1.default.equal(request.path.message_id, 'msg-file-in-1');
+                    strict_1.default.equal(request.path.file_key, 'file-key-in-1');
+                    strict_1.default.equal(request.params.type, 'file');
+                    return {
+                        headers: { 'content-type': 'application/pdf' },
+                        getReadableStream: () => node_stream_1.Readable.from([fileBytes]),
+                    };
+                },
+            },
+            messageReaction: {
+                create: async () => ({ data: { reaction_id: 'reaction-1' } }),
+            },
+        },
+    };
+    const gateway = new local_core_lark_gateway_js_1.LocalCoreLarkGateway({
+        store: {
+            expirePendingPairings: () => { },
+            getAuthorizedUser: () => ({
+                id: 'auth-1',
+                workspace_id: 'default',
+                platform: 'lark',
+                platform_user_id: 'user-1',
+                chat_id: 'chat-1',
+                display_name: 'User',
+                thread_id: 'thread-1',
+            }),
+            getPlatformThreadBinding: () => ({
+                workspace_id: 'default',
+                platform: 'lark',
+                chat_id: 'chat-1',
+                platform_user_id: 'user-1',
+                thread_id: 'thread-1',
+                last_platform_message_id: null,
+            }),
+            getLatestRunForThread: () => null,
+            clearPlatformThreadMessageId: () => { },
+        },
+        readConfig: async () => ({
+            projects: [{
+                    name: 'default',
+                    root: '/tmp/project',
+                    platforms: [{
+                            type: 'lark',
+                            options: {
+                                app_id: 'app-1',
+                                app_secret: 'secret-1',
+                            },
+                        }],
+                }],
+        }),
+        getWorkspaceRouter: () => ({
+            getThreadSessionKey: (threadId) => `session:${threadId}`,
+            sendThreadMessage: async (threadId, content) => {
+                sentMessages.push({ threadId, content });
+                return { runId: 'run-1' };
+            },
+        }),
+        eventBus: { emit: () => { }, on: () => () => { } },
+    });
+    const internals = gateway;
+    internals.runtime.set('default', {
+        workspaceId: 'default',
+        enabled: true,
+        status: 'running',
+        connected: true,
+        appId: 'app-1',
+        client,
+    });
+    await internals.handleMessageEvent('default', {
+        event: {
+            sender: {
+                sender_id: { user_id: 'user-1' },
+            },
+            message: {
+                message_id: 'msg-file-in-1',
+                message_type: 'file',
+                chat_id: 'chat-1',
+                content: JSON.stringify({ file_key: 'file-key-in-1', file_name: 'report.pdf' }),
+            },
+        },
+    });
+    strict_1.default.equal(sentMessages.length, 1);
+    strict_1.default.equal(sentMessages[0]?.threadId, 'thread-1');
+    strict_1.default.match(sentMessages[0]?.content?.displayText, /\[User Message\]\n\[File: report\.pdf\]\n\[\/User Message\]/);
+    strict_1.default.deepEqual(sentMessages[0]?.content?.contentParts?.map((part) => part.type), ['text', 'file']);
+    strict_1.default.equal(sentMessages[0]?.content?.contentParts?.[1]?.mimeType, 'application/pdf');
+    strict_1.default.equal(sentMessages[0]?.content?.contentParts?.[1]?.data, fileBytes.toString('base64'));
+    strict_1.default.equal(sentMessages[0]?.content?.contentParts?.[1]?.fileName, 'report.pdf');
+});
+(0, node_test_1.default)('lark group text messages strip the bot mention before dispatching', async () => {
+    const sentMessages = [];
+    const gateway = new local_core_lark_gateway_js_1.LocalCoreLarkGateway({
+        store: {
+            expirePendingPairings: () => { },
+            getAuthorizedUser: () => ({
+                id: 'auth-1',
+                workspace_id: 'default',
+                platform: 'lark',
+                platform_user_id: 'user-1',
+                chat_id: 'oc_group_1',
+                display_name: 'User',
+                thread_id: 'thread-1',
+            }),
+            getPlatformThreadBinding: () => ({
+                workspace_id: 'default',
+                platform: 'lark',
+                chat_id: 'oc_group_1',
+                platform_user_id: 'user-1',
+                thread_id: 'thread-1',
+                last_platform_message_id: null,
+            }),
+            getLatestRunForThread: () => null,
+            clearPlatformThreadMessageId: () => { },
+        },
+        readConfig: async () => ({ projects: [] }),
+        getWorkspaceRouter: () => ({
+            getThreadSessionKey: (threadId) => `session:${threadId}`,
+            sendThreadMessage: async (threadId, content) => {
+                sentMessages.push({ threadId, content });
+                return { runId: 'run-1' };
+            },
+        }),
+        eventBus: { emit: () => { }, on: () => () => { } },
+    });
+    const internals = gateway;
+    internals.runtime.set('default', {
+        workspaceId: 'default',
+        enabled: true,
+        status: 'running',
+        connected: true,
+        appId: 'app-1',
+        botOpenId: 'ou_bot',
+        groupReplyAll: false,
+        client: {
+            im: {
+                messageReaction: {
+                    create: async () => ({ data: { reaction_id: 'reaction-1' } }),
+                },
+            },
+        },
+    });
+    await internals.handleMessageEvent('default', {
+        event: {
+            sender: {
+                sender_id: { user_id: 'user-1' },
+            },
+            message: {
+                message_id: 'msg-group-1',
+                message_type: 'text',
+                chat_id: 'oc_group_1',
+                chat_type: 'group',
+                mentions: [
+                    { key: '@_user_1', id: { open_id: 'ou_bot' }, name: 'AgentDock' },
+                    { key: '@_user_2', id: { open_id: 'ou_other' }, name: '张三' },
+                ],
+                content: JSON.stringify({ text: '@_user_1 ask @_user_2 to review' }),
+            },
+        },
+    });
+    strict_1.default.equal(sentMessages.length, 1);
+    strict_1.default.equal(sentMessages[0]?.threadId, 'thread-1');
+    strict_1.default.match(sentMessages[0]?.content, /\[User Message\]\nask @张三 to review\n\[\/User Message\]/);
+});
+(0, node_test_1.default)('lark group text messages ignore non-mentioned bot messages by default', async () => {
+    const sentMessages = [];
+    const gateway = new local_core_lark_gateway_js_1.LocalCoreLarkGateway({
+        store: {
+            expirePendingPairings: () => { },
+            getAuthorizedUser: () => {
+                throw new Error('group message without bot mention should not look up authorization');
+            },
+        },
+        readConfig: async () => ({ projects: [] }),
+        getWorkspaceRouter: () => ({
+            sendThreadMessage: async (threadId, content) => {
+                sentMessages.push({ threadId, content });
+                return { runId: 'run-1' };
+            },
+        }),
+        eventBus: { emit: () => { }, on: () => () => { } },
+    });
+    const internals = gateway;
+    internals.runtime.set('default', {
+        workspaceId: 'default',
+        enabled: true,
+        status: 'running',
+        connected: true,
+        appId: 'app-1',
+        botOpenId: 'ou_bot',
+        groupReplyAll: false,
+        client: {},
+    });
+    await internals.handleMessageEvent('default', {
+        event: {
+            sender: {
+                sender_id: { user_id: 'user-1' },
+            },
+            message: {
+                message_id: 'msg-group-2',
+                message_type: 'text',
+                chat_id: 'oc_group_1',
+                chat_type: 'group',
+                mentions: [{ key: '@_user_2', id: { open_id: 'ou_other' }, name: '张三' }],
+                content: JSON.stringify({ text: 'ask @_user_2 to review' }),
+            },
+        },
+    });
+    strict_1.default.equal(sentMessages.length, 0);
+});
+(0, node_test_1.default)('lark inbound messages create a chat binding when an authorized user has an old direct thread', async () => {
+    const bindings = [];
+    const createdThreads = [];
+    const sentMessages = [];
+    const gateway = new local_core_lark_gateway_js_1.LocalCoreLarkGateway({
+        store: {
+            expirePendingPairings: () => { },
+            getAuthorizedUser: () => ({
+                id: 'auth-1',
+                workspace_id: 'project-1',
+                platform: 'lark:lark-1',
+                platform_user_id: 'user-1',
+                chat_id: 'old-direct-chat',
+                display_name: 'User',
+                thread_id: 'old-thread-1',
+            }),
+            getPlatformThreadBinding: () => undefined,
+            upsertPlatformThreadBinding: (binding) => bindings.push(binding),
+            updateAuthorizedUserThread: () => { },
+            getLatestRunForThread: () => null,
+            clearPlatformThreadMessageId: () => { },
+        },
+        readConfig: async () => ({ projects: [] }),
+        getWorkspaceRouter: () => ({
+            createThread: async (workspaceId, title) => {
+                const thread = { id: 'group-thread-1', workspaceId, title };
+                createdThreads.push(thread);
+                return thread;
+            },
+            getThreadSessionKey: (threadId) => `session:${threadId}`,
+            sendThreadMessage: async (threadId, content) => {
+                sentMessages.push({ threadId, content });
+                return { runId: 'run-1' };
+            },
+        }),
+        eventBus: { emit: () => { }, on: () => () => { } },
+    });
+    const internals = gateway;
+    internals.runtime.set('project-1::lark-1', {
+        workspaceId: 'project-1',
+        instanceId: 'lark-1',
+        platformKey: 'lark:lark-1',
+        enabled: true,
+        status: 'running',
+        connected: true,
+        appId: 'app-1',
+        botOpenId: 'ou_bot',
+        groupReplyAll: false,
+        client: {
+            im: {
+                messageReaction: {
+                    create: async () => ({ data: { reaction_id: 'reaction-1' } }),
+                },
+            },
+        },
+    });
+    await internals.handleMessageEvent('project-1', 'lark-1', 'lark:lark-1', {
+        event: {
+            sender: {
+                sender_id: { user_id: 'user-1' },
+            },
+            message: {
+                message_id: 'msg-group-old-user',
+                message_type: 'text',
+                chat_id: 'new-group-chat',
+                chat_type: 'group',
+                mentions: [{ key: '@_user_1', id: { open_id: 'ou_bot' }, name: 'AgentDock' }],
+                content: JSON.stringify({ text: '@_user_1 hi' }),
+            },
+        },
+    });
+    strict_1.default.deepEqual(createdThreads, [{ id: 'group-thread-1', workspaceId: 'project-1', title: 'user-1' }]);
+    strict_1.default.equal(bindings.length, 1);
+    strict_1.default.equal(bindings[0]?.platform, 'lark:lark-1');
+    strict_1.default.equal(bindings[0]?.chat_id, 'new-group-chat');
+    strict_1.default.equal(bindings[0]?.platform_user_id, 'user-1');
+    strict_1.default.equal(bindings[0]?.thread_id, 'group-thread-1');
+    strict_1.default.equal(sentMessages[0]?.threadId, 'group-thread-1');
+});
+(0, node_test_1.default)('lark channel can upload and send a local file', async () => {
+    const tempDir = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'lark-file-send-'));
+    try {
+        const filePath = (0, node_path_1.join)(tempDir, 'report.pdf');
+        (0, node_fs_1.writeFileSync)(filePath, 'pdf content');
+        const uploads = [];
+        const messages = [];
+        const client = {
+            im: {
+                file: {
+                    create: async (request) => {
+                        uploads.push(request);
+                        await new Promise((resolve, reject) => {
+                            request.data.file.on('data', () => { });
+                            request.data.file.on('error', reject);
+                            request.data.file.on('end', resolve);
+                        });
+                        return { file_key: 'file-key-1' };
+                    },
+                },
+                message: {
+                    create: async (request) => {
+                        messages.push(request);
+                        return { data: { message_id: 'msg-file-1' } };
+                    },
+                },
+            },
+        };
+        const gateway = new local_core_lark_gateway_js_1.LocalCoreLarkGateway({
+            store: {},
+            readConfig: async () => null,
+            getWorkspaceRouter: () => ({}),
+            eventBus: { emit: () => { }, on: () => () => { } },
+        });
+        const internals = gateway;
+        internals.runtime.set('default', {
+            workspaceId: 'default',
+            enabled: true,
+            status: 'running',
+            connected: true,
+            appId: 'app-1',
+            client,
+        });
+        const result = await gateway.sendFile('default', {
+            path: filePath,
+            channelId: 'oc_chat_1',
+        });
+        strict_1.default.equal(uploads.length, 1);
+        strict_1.default.equal(uploads[0]?.data?.file_type, 'pdf');
+        strict_1.default.equal(uploads[0]?.data?.file_name, 'report.pdf');
+        strict_1.default.equal(messages.length, 1);
+        strict_1.default.equal(messages[0]?.params?.receive_id_type, 'chat_id');
+        strict_1.default.equal(messages[0]?.data?.receive_id, 'oc_chat_1');
+        strict_1.default.equal(messages[0]?.data?.msg_type, 'file');
+        strict_1.default.deepEqual(JSON.parse(messages[0]?.data?.content), { file_key: 'file-key-1' });
+        strict_1.default.deepEqual(result, {
+            platform: 'lark',
+            workspaceId: 'default',
+            channelId: 'oc_chat_1',
+            messageId: 'msg-file-1',
+            fileKey: 'file-key-1',
+            fileName: 'report.pdf',
+            fileSize: Buffer.byteLength('pdf content'),
+        });
+    }
+    finally {
+        (0, node_fs_1.rmSync)(tempDir, { recursive: true, force: true });
+    }
+});
+(0, node_test_1.default)('lark message callbacks acknowledge before long thread runs finish', async () => {
+    let registeredHandlers = {};
+    let sentMessages = 0;
+    const logs = [];
+    const gateway = new local_core_lark_gateway_js_1.LocalCoreLarkGateway({
+        store: {
+            expirePendingPairings: () => { },
+            getAuthorizedUser: () => ({
+                id: 'auth-1',
+                workspace_id: 'default',
+                platform_user_id: 'user-1',
+                chat_id: 'chat-1',
+                display_name: 'User',
+                thread_id: 'thread-1',
+            }),
+            getPlatformThreadBinding: () => ({
+                workspace_id: 'default',
+                platform: 'lark',
+                chat_id: 'chat-1',
+                platform_user_id: 'user-1',
+                thread_id: 'thread-1',
+                last_platform_message_id: null,
+            }),
+            getLatestRunForThread: () => null,
+            clearPlatformThreadMessageId: () => { },
+            listPendingPairings: () => [],
+            listAuthorizedUsers: () => [],
+        },
+        readConfig: async () => ({
+            projects: [
+                {
+                    name: 'default',
+                    agent: { type: 'claudecode', providers: [] },
+                    platforms: [{ type: 'lark', options: { app_id: 'app-1', app_secret: 'secret-1', auto_approve: true } }],
+                },
+            ],
+        }),
+        getWorkspaceRouter: () => ({
+            getThreadSessionKey: (threadId) => `session:${threadId}`,
+            sendThreadMessage: async () => {
+                sentMessages++;
+                return new Promise(() => { });
+            },
+        }),
+        eventBus: { emit: () => { }, on: () => () => { } },
+        log: (message) => logs.push(message),
+    });
+    gateway.larkModulePromise = Promise.resolve({
+        AppType: { SelfBuild: 'self-build' },
+        Domain: { Feishu: 'feishu' },
+        LoggerLevel: { info: 'info' },
+        Client: class {
+        },
+        EventDispatcher: class {
+            register(handlers) {
+                registeredHandlers = handlers;
+            }
+        },
+        WSClient: class {
+            async start() { }
+        },
+    });
+    await gateway.enable('default');
+    const handler = registeredHandlers['im.message.receive_v1'];
+    strict_1.default.equal(typeof handler, 'function');
+    const result = await Promise.race([
+        handler({
+            event: {
+                sender: { sender_id: { user_id: 'user-1' } },
+                message: {
+                    message_id: 'msg-1',
+                    chat_id: 'chat-1',
+                    message_type: 'text',
+                    content: JSON.stringify({ text: 'hi' }),
+                },
+            },
+        }),
+        new Promise((resolve) => setTimeout(() => resolve('timed-out'), 25)),
+    ]);
+    strict_1.default.notEqual(result, 'timed-out');
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    strict_1.default.equal(sentMessages, 1);
+    strict_1.default.ok(logs.some((line) => line.includes('received im.message.receive_v1') &&
+        line.includes('message=msg-1') &&
+        line.includes('type=text') &&
+        line.includes('chat=chat-1') &&
+        line.includes('sender=user-1')));
+    strict_1.default.ok(logs.some((line) => line.includes('handling message event') && line.includes('contentBytes=')));
+});
+(0, node_test_1.default)('lark inbound messages use active runtime binding before config refresh catches up', async () => {
+    const users = new Map();
+    const threadBindings = new Map();
+    const createdThreads = [];
+    const updatedModes = [];
+    const sentCards = [];
+    const platformKey = 'lark:lark-hot';
+    const bindingKey = `${platformKey}:chat-1:user-1`;
+    const gateway = new local_core_lark_gateway_js_1.LocalCoreLarkGateway({
+        store: {
+            expirePendingPairings: () => { },
+            listPendingPairings: () => [],
+            listAuthorizedUsers: () => [...users.values()],
+            getAuthorizedUser: (_workspaceId, platformUserId, requestedPlatform) => users.get(`${requestedPlatform}:${platformUserId}`),
+            createAuthorizedUser: (user) => users.set(`${user.platform}:${user.platform_user_id}`, user),
+            updateAuthorizedUserThread: (_workspaceId, platformUserId, threadId, requestedPlatform) => {
+                users.set(`${requestedPlatform}:${platformUserId}`, { ...users.get(`${requestedPlatform}:${platformUserId}`), thread_id: threadId });
+            },
+            getPlatformThreadBinding: () => threadBindings.get(bindingKey),
+            upsertPlatformThreadBinding: (binding) => threadBindings.set(bindingKey, binding),
+            getThreadRow: (threadId) => ({ id: threadId, agent_mode: threadId === 'thread-1' ? 'bypassPermissions' : 'default' }),
+            updateThreadAgentMode: (threadId, mode) => updatedModes.push({ threadId, mode }),
+            getLatestRunForThread: () => null,
+            clearPlatformThreadMessageId: () => { },
+        },
+        readConfig: async () => ({ projects: [] }),
+        getWorkspaceRouter: () => ({
+            createThread: async (_workspaceId, title) => {
+                const id = `thread-${createdThreads.length + 1}`;
+                createdThreads.push(`${id}:${title}`);
+                return { id };
+            },
+            getThreadSessionKey: (threadId) => `session:${threadId}`,
+            sendThreadMessage: async () => ({ runId: 'run-1' }),
+        }),
+        eventBus: { emit: () => { }, on: () => () => { } },
+    });
+    const internals = gateway;
+    internals.runtime.set('project-1::lark-hot', {
+        workspaceId: 'project-1',
+        instanceId: 'lark-hot',
+        displayName: 'Lark Hot',
+        platformKey,
+        enabled: true,
+        status: 'running',
+        connected: true,
+        appId: 'app-1',
+        autoApprove: true,
+        cardActionsEnabled: true,
+        client: {
+            im: {
+                message: {
+                    create: async (request) => {
+                        sentCards.push(JSON.parse(String(request.data.content || '{}')));
+                        return { data: { message_id: 'card-1' } };
+                    },
+                },
+                messageReaction: {
+                    create: async () => ({ data: { reaction_id: 'reaction-1' } }),
+                },
+            },
+        },
+    });
+    await gateway.handleInboundMessage({
+        workspaceId: 'project-1',
+        instanceId: 'lark-hot',
+        platformKey,
+        platformUserId: 'user-1',
+        chatId: 'chat-1',
+        displayName: 'User',
+        text: '/new',
+        messageId: 'msg-1',
+    });
+    strict_1.default.equal(users.get(`${platformKey}:user-1`)?.thread_id, 'thread-2');
+    strict_1.default.deepEqual(createdThreads.map((item) => item.split(':')[0]), ['thread-1', 'thread-2']);
+    strict_1.default.deepEqual(updatedModes, [{ threadId: 'thread-2', mode: 'bypassPermissions' }]);
+    strict_1.default.match(sentCards[0]?.elements?.[0]?.content || '', /已开始新会话/);
+});
+(0, node_test_1.default)('lark rendering suppresses noisy pending tool progress cards', () => {
+    const turn = (0, runtime_state_js_1.createLarkTurnState)('session-1');
+    const rendered = (0, runtime_state_js_1.renderLarkBridgeEventMessage)(turn, {
+        type: 'update_message',
+        sessionKey: 'session-1',
+        replyCtx: 'run-1',
+        previewHandle: 'tool-1',
+        bridgeKind: 'tool',
+        content: 'bash pending',
+        toolCall: {
+            id: 'tool-1',
+            name: 'bash',
+            status: 'pending',
+            output: '',
+        },
+    });
+    strict_1.default.equal(rendered.text, '');
+    strict_1.default.equal(rendered.key, 'noop');
+    const completed = (0, runtime_state_js_1.renderLarkBridgeEventMessage)(turn, {
+        type: 'update_message',
+        sessionKey: 'session-1',
+        replyCtx: 'run-1',
+        previewHandle: 'tool-1',
+        bridgeKind: 'tool',
+        content: 'bash completed',
+        toolCall: {
+            id: 'tool-1',
+            name: 'bash: Tool update',
+            status: 'completed',
+            output: 'verbose output',
+        },
+    });
+    strict_1.default.equal(completed.text, '🔧 bash: Tool update');
+    strict_1.default.equal(completed.delivery, 'message');
+});
+(0, node_test_1.default)('lark channel can request an official app registration QR code without extra setup', async () => {
+    const originalFetch = globalThis.fetch;
+    const requests = [];
+    globalThis.fetch = (async (input, init) => {
+        requests.push({
+            url: String(input),
+            method: init?.method,
+            body: String(init?.body || ''),
+            headers: new Headers(init?.headers),
+        });
+        return new Response(JSON.stringify({
+            device_code: 'device-code-1',
+            user_code: 'ABCD-EFGH',
+            expires_in: 300,
+            interval: 5,
+        }), {
+            status: 200,
+            headers: { 'Content-Type': 'application/json' },
+        });
+    });
+    try {
+        const gateway = new local_core_lark_gateway_js_1.LocalCoreLarkGateway({
+            store: {},
+            readConfig: async () => ({
+                projects: [
+                    {
+                        name: 'default',
+                        agent: { type: 'localcore-acp', providers: [] },
+                        platforms: [{ type: 'lark', options: {} }],
+                    },
+                ],
+            }),
+            getWorkspaceRouter: () => ({}),
+            eventBus: { emit: () => { }, on: () => () => { } },
+        });
+        const result = await gateway.getQrCode('default');
+        strict_1.default.deepEqual(result, {
+            ticket: 'device-code-1',
+            expiresIn: 300,
+            interval: 5,
+            qrCodeUrl: 'https://open.feishu.cn/page/openclaw?user_code=ABCD-EFGH&from=openclaw',
+            instanceId: 'default',
+            displayName: 'Lark 1',
+        });
+        strict_1.default.equal(requests[0]?.url, 'https://accounts.feishu.cn/oauth/v1/app/registration');
+        strict_1.default.equal(requests[0]?.method, 'POST');
+        strict_1.default.equal(requests[0]?.headers.get('Content-Type'), 'application/x-www-form-urlencoded');
+        strict_1.default.equal(new URLSearchParams(requests[0]?.body).get('action'), 'begin');
+        strict_1.default.equal(new URLSearchParams(requests[0]?.body).get('archetype'), 'PersonalAgent');
+        strict_1.default.equal(new URLSearchParams(requests[0]?.body).get('request_callbacks'), null);
+    }
+    finally {
+        globalThis.fetch = originalFetch;
+    }
+});
+(0, node_test_1.default)('lark app registration QR confirmation returns app credentials', async () => {
+    const originalFetch = globalThis.fetch;
+    const requests = [];
+    globalThis.fetch = (async (input, init) => {
+        const url = String(input);
+        requests.push({ url, body: String(init?.body || '') });
+        return new Response(JSON.stringify({
+            client_id: 'cli_lark_1',
+            client_secret: 'secret-1',
+        }), {
+            status: 200,
+            headers: { 'Content-Type': 'application/json' },
+        });
+    });
+    try {
+        const gateway = new local_core_lark_gateway_js_1.LocalCoreLarkGateway({
+            store: {},
+            readConfig: async () => ({
+                projects: [
+                    {
+                        name: 'default',
+                        agent: { type: 'localcore-acp', providers: [] },
+                        platforms: [{ type: 'lark', options: {} }],
+                    },
+                ],
+            }),
+            getWorkspaceRouter: () => ({}),
+            eventBus: { emit: () => { }, on: () => () => { } },
+        });
+        const result = await gateway.checkQrCodeStatus('default', 'lark-ticket-1');
+        strict_1.default.equal(requests[0]?.url, 'https://accounts.feishu.cn/oauth/v1/app/registration');
+        strict_1.default.equal(new URLSearchParams(requests[0]?.body).get('action'), 'poll');
+        strict_1.default.equal(new URLSearchParams(requests[0]?.body).get('device_code'), 'lark-ticket-1');
+        strict_1.default.deepEqual(result, {
+            status: 'confirmed',
+            credentials: {
+                appId: 'cli_lark_1',
+                appSecret: 'secret-1',
+            },
+        });
+    }
+    finally {
+        globalThis.fetch = originalFetch;
+    }
+});
+(0, node_test_1.default)('lark channel keeps multiple bot instances in one workspace isolated', async () => {
+    const gateway = new local_core_lark_gateway_js_1.LocalCoreLarkGateway({
+        store: {
+            expirePendingPairings: () => { },
+            listPendingPairings: () => [],
+            listAuthorizedUsers: () => [],
+        },
+        readConfig: async () => ({
+            projects: [
+                {
+                    name: 'default',
+                    agent: { type: 'localcore-acp', providers: [] },
+                    platforms: [
+                        { type: 'lark', options: { instance_id: 'bot-a', app_id: 'cli_a', app_secret: 'secret-a' } },
+                        { type: 'lark', options: { instance_id: 'bot-b', app_id: 'cli_b', app_secret: 'secret-b' } },
+                    ],
+                },
+            ],
+        }),
+        getWorkspaceRouter: () => ({}),
+        eventBus: { emit: () => { }, on: () => () => { } },
+    });
+    gateway.larkModulePromise = Promise.resolve({
+        AppType: { SelfBuild: 'self-build' },
+        Domain: { Feishu: 'feishu' },
+        LoggerLevel: { info: 'info' },
+        Client: class {
+        },
+        EventDispatcher: class {
+            register() { }
+        },
+        WSClient: class {
+            async start() { }
+        },
+    });
+    await gateway.refreshBindings();
+    const statuses = gateway.listStatuses();
+    strict_1.default.deepEqual(statuses.map((status) => [status.workspaceId, status.instanceId, status.appId, status.status]), [
+        ['default', 'bot-a', 'cli_a', 'running'],
+        ['default', 'bot-b', 'cli_b', 'running'],
+    ]);
+});