@kafca/agentdock 0.1.43 → 0.1.44

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

@@ -0,0 +1,927 @@
+"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 local_core_weixin_gateway_js_1 = require("../../services/local-ai-core/src/channel/weixin/local-core-weixin-gateway.js");
+(0, node_test_1.default)('weixin channel can encrypt, upload, and send a local file', async () => {
+    const tempDir = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'weixin-file-send-'));
+    const originalFetch = globalThis.fetch;
+    try {
+        const filePath = (0, node_path_1.join)(tempDir, 'report.txt');
+        (0, node_fs_1.writeFileSync)(filePath, 'hello weixin');
+        const uploadUrlRequests = [];
+        const cdnUploads = [];
+        const sentMessages = [];
+        globalThis.fetch = (async (url, init) => {
+            const target = String(url);
+            if (target.endsWith('/ilink/bot/getuploadurl')) {
+                uploadUrlRequests.push(JSON.parse(String(init?.body || '{}')));
+                return {
+                    ok: true,
+                    json: async () => ({ ret: 0, upload_param: 'upload-param-1' }),
+                };
+            }
+            if (target.includes('/upload?')) {
+                const body = init?.body instanceof Uint8Array ? init.body : new Uint8Array();
+                cdnUploads.push({ url: target, size: body.byteLength });
+                return {
+                    ok: true,
+                    headers: {
+                        get: (name) => name.toLowerCase() === 'x-encrypted-param' ? 'download-param-1' : null,
+                    },
+                };
+            }
+            if (target.endsWith('/ilink/bot/sendmessage')) {
+                sentMessages.push(JSON.parse(String(init?.body || '{}')));
+                return {
+                    ok: true,
+                    json: async () => ({ ret: 0 }),
+                };
+            }
+            throw new Error(`Unexpected fetch ${target}`);
+        });
+        const gateway = new local_core_weixin_gateway_js_1.LocalCoreWeixinGateway({
+            store: {
+                getPlatformThreadBinding: () => ({
+                    workspace_id: 'default',
+                    platform: 'weixin',
+                    chat_id: 'user-1',
+                    platform_user_id: 'user-1',
+                    thread_id: 'thread-1',
+                    last_platform_message_id: 'ctx-1',
+                }),
+                listAuthorizedUsers: () => [],
+            },
+            readConfig: async () => ({
+                projects: [{
+                        name: 'default',
+                        root: '/tmp/project',
+                        platforms: [{
+                                type: 'weixin',
+                                options: {
+                                    token: 'token-1',
+                                    account_id: 'account-1',
+                                    base_url: 'https://weixin.example',
+                                    cdn_base_url: 'https://cdn.example/c2c',
+                                },
+                            }],
+                    }],
+            }),
+            getWorkspaceRouter: () => ({}),
+            eventBus: { emit: () => { }, on: () => () => { } },
+        });
+        const internals = gateway;
+        internals.runtime.set('default', {
+            workspaceId: 'default',
+            enabled: true,
+            status: 'running',
+            connected: true,
+            accountId: 'account-1',
+        });
+        const result = await gateway.sendFile('default', {
+            path: filePath,
+            channelId: 'user-1',
+            participantId: 'user-1',
+        });
+        strict_1.default.equal(uploadUrlRequests.length, 1);
+        strict_1.default.equal(uploadUrlRequests[0]?.media_type, 3);
+        strict_1.default.equal(uploadUrlRequests[0]?.to_user_id, 'user-1');
+        strict_1.default.equal(uploadUrlRequests[0]?.rawsize, Buffer.byteLength('hello weixin'));
+        strict_1.default.equal(uploadUrlRequests[0]?.filesize, 16);
+        strict_1.default.equal(cdnUploads.length, 1);
+        strict_1.default.match(cdnUploads[0]?.url || '', /encrypted_query_param=upload-param-1/);
+        strict_1.default.equal(cdnUploads[0]?.size, 16);
+        strict_1.default.equal(sentMessages.length, 1);
+        const message = sentMessages[0]?.msg;
+        strict_1.default.equal(message?.to_user_id, 'user-1');
+        strict_1.default.equal(message?.context_token, 'ctx-1');
+        strict_1.default.equal(message?.item_list?.[0]?.type, 4);
+        strict_1.default.equal(message?.item_list?.[0]?.file_item?.file_name, 'report.txt');
+        strict_1.default.equal(message?.item_list?.[0]?.file_item?.len, String(Buffer.byteLength('hello weixin')));
+        strict_1.default.equal(message?.item_list?.[0]?.file_item?.media?.encrypt_query_param, 'download-param-1');
+        strict_1.default.equal(result.platform, 'weixin');
+        strict_1.default.equal(result.channelId, 'user-1');
+        strict_1.default.equal(result.fileName, 'report.txt');
+        strict_1.default.equal(result.fileSize, Buffer.byteLength('hello weixin'));
+        strict_1.default.match(result.messageId, /^openclaw-weixin-/);
+        strict_1.default.ok(result.fileKey);
+    }
+    finally {
+        globalThis.fetch = originalFetch;
+        (0, node_fs_1.rmSync)(tempDir, { recursive: true, force: true });
+    }
+});
+(0, node_test_1.default)('weixin channel can request a QR code without platform options', async () => {
+    const originalFetch = globalThis.fetch;
+    const stateDir = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'weixin-channel-qr-'));
+    const requests = [];
+    globalThis.fetch = (async (input, init) => {
+        requests.push({
+            url: String(input),
+            headers: new Headers(init?.headers),
+        });
+        return new Response(JSON.stringify({
+            qrcode: 'ticket-1',
+            qrcode_img_content: 'https://liteapp.weixin.qq.com/q/test?qrcode=ticket-1&bot_type=3',
+            expired: 180,
+        }), {
+            status: 200,
+            headers: { 'Content-Type': 'application/json' },
+        });
+    });
+    try {
+        const gateway = new local_core_weixin_gateway_js_1.LocalCoreWeixinGateway({
+            store: {},
+            readConfig: async () => ({
+                projects: [
+                    {
+                        name: 'default',
+                        agent: { type: 'localcore-acp', providers: [] },
+                        platforms: [{ type: 'weixin', options: { state_dir: stateDir } }],
+                    },
+                ],
+            }),
+            getWorkspaceRouter: () => ({}),
+            eventBus: { emit: () => { }, on: () => () => { } },
+        });
+        const result = await gateway.getQrCode('default');
+        strict_1.default.deepEqual(result, {
+            ticket: 'ticket-1',
+            expiresIn: 180,
+            qrCodeUrl: 'https://liteapp.weixin.qq.com/q/test?qrcode=ticket-1&bot_type=3',
+            instanceId: 'default',
+            displayName: 'WeChat 1',
+        });
+        strict_1.default.equal(requests[0]?.url, 'https://ilinkai.weixin.qq.com/ilink/bot/get_bot_qrcode?bot_type=3');
+        strict_1.default.equal(requests[0]?.headers.has('Authorization'), false);
+        strict_1.default.equal(requests[0]?.headers.has('AuthorizationType'), false);
+    }
+    finally {
+        globalThis.fetch = originalFetch;
+        (0, node_fs_1.rmSync)(stateDir, { recursive: true, force: true });
+    }
+});
+(0, node_test_1.default)('weixin QR confirmation persists credentials and starts authenticated polling', async () => {
+    const originalFetch = globalThis.fetch;
+    const stateDir = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'weixin-channel-'));
+    const requests = [];
+    globalThis.fetch = (async (input, init) => {
+        const url = String(input);
+        requests.push({
+            url,
+            headers: new Headers(init?.headers),
+        });
+        if (url.includes('/get_qrcode_status')) {
+            return new Response(JSON.stringify({
+                status: 'confirmed',
+                bot_token: 'bot-token-1',
+                baseurl: 'https://ilinkai.weixin.qq.com',
+                ilink_bot_id: 'bot-1',
+                ilink_user_id: 'user-1',
+            }), {
+                status: 200,
+                headers: { 'Content-Type': 'application/json' },
+            });
+        }
+        return new Promise((_resolve, reject) => {
+            init?.signal?.addEventListener('abort', () => reject(new Error('aborted')), { once: true });
+        });
+    });
+    const gateway = new local_core_weixin_gateway_js_1.LocalCoreWeixinGateway({
+        store: {
+            expirePendingPairings: () => { },
+            listPendingPairings: () => [],
+            listAuthorizedUsers: () => [],
+        },
+        readConfig: async () => ({
+            projects: [
+                {
+                    name: 'default',
+                    agent: { type: 'localcore-acp', providers: [] },
+                    platforms: [{ type: 'weixin', options: { state_dir: stateDir } }],
+                },
+            ],
+        }),
+        getWorkspaceRouter: () => ({}),
+        eventBus: { emit: () => { }, on: () => () => { } },
+    });
+    try {
+        const result = await gateway.checkQrCodeStatus('default', 'ticket-1');
+        await new Promise((resolve) => setTimeout(resolve, 0));
+        strict_1.default.equal(result.status, 'confirmed');
+        const pollingRequest = requests.find((request) => request.url.endsWith('/ilink/bot/getupdates'));
+        strict_1.default.equal(pollingRequest?.headers.get('Authorization'), 'Bearer bot-token-1');
+        strict_1.default.equal(pollingRequest?.headers.get('AuthorizationType'), 'ilink_bot_token');
+    }
+    finally {
+        await gateway.stop();
+        globalThis.fetch = originalFetch;
+        (0, node_fs_1.rmSync)(stateDir, { recursive: true, force: true });
+    }
+});
+(0, node_test_1.default)('weixin channel keeps multiple bot instances in one workspace isolated', async () => {
+    const gateway = new local_core_weixin_gateway_js_1.LocalCoreWeixinGateway({
+        store: {
+            expirePendingPairings: () => { },
+            listPendingPairings: () => [],
+            listAuthorizedUsers: () => [],
+        },
+        readConfig: async () => ({
+            projects: [
+                {
+                    name: 'default',
+                    agent: { type: 'localcore-acp', providers: [] },
+                    platforms: [
+                        { type: 'weixin', options: { instance_id: 'wx-a', account_id: 'account-a' } },
+                        { type: 'weixin', options: { instance_id: 'wx-b', account_id: 'account-b' } },
+                    ],
+                },
+            ],
+        }),
+        getWorkspaceRouter: () => ({}),
+        eventBus: { emit: () => { }, on: () => () => { } },
+    });
+    await gateway.refreshBindings();
+    const statuses = gateway.listStatuses();
+    strict_1.default.deepEqual(statuses.map((status) => [status.workspaceId, status.instanceId, status.appId, status.status]), [
+        ['default', 'wx-a', 'account-a', 'stopped'],
+        ['default', 'wx-b', 'account-b', 'stopped'],
+    ]);
+});
+(0, node_test_1.default)('weixin inbound message handling is idempotent by message identity', async () => {
+    const sentThreadMessages = [];
+    const users = new Map();
+    const threadBindings = new Map();
+    const bindingKey = 'default:chat-1:user-1';
+    const gateway = new local_core_weixin_gateway_js_1.LocalCoreWeixinGateway({
+        store: {
+            expirePendingPairings: () => { },
+            listPendingPairings: () => [],
+            listPairingRequests: () => [],
+            listAuthorizedUsers: () => [...users.values()],
+            getAuthorizedUser: (_workspaceId, platformUserId) => users.get(platformUserId),
+            createAuthorizedUser: (user) => users.set(user.platform_user_id, user),
+            updateAuthorizedUserThread: (_workspaceId, platformUserId, threadId) => {
+                users.set(platformUserId, { ...users.get(platformUserId), thread_id: threadId });
+            },
+            getPlatformThreadBinding: () => threadBindings.get(bindingKey),
+            upsertPlatformThreadBinding: (binding) => threadBindings.set(bindingKey, binding),
+            updatePlatformThreadMessageId: (_workspaceId, _chatId, _platformUserId, messageId) => {
+                threadBindings.set(bindingKey, { ...threadBindings.get(bindingKey), last_platform_message_id: messageId });
+            },
+            getLatestRunForThread: () => null,
+        },
+        readConfig: async () => ({
+            projects: [
+                {
+                    name: 'default',
+                    agent: { type: 'localcore-acp', providers: [] },
+                    platforms: [{ type: 'weixin', options: {} }],
+                },
+            ],
+        }),
+        getWorkspaceRouter: () => ({
+            createThread: async () => ({ id: 'thread-1' }),
+            getThreadSessionKey: (threadId) => `session:${threadId}`,
+            sendThreadMessage: async (_threadId, text) => {
+                sentThreadMessages.push(text);
+                return { runId: 'run-1' };
+            },
+        }),
+        eventBus: { emit: () => { }, on: () => () => { } },
+    });
+    const input = {
+        workspaceId: 'default',
+        platformUserId: 'user-1',
+        chatId: 'chat-1',
+        displayName: 'User',
+        text: 'hello',
+        messageId: 'msg-1',
+        contextToken: 'ctx-1',
+    };
+    await gateway.handleInboundMessage(input);
+    await gateway.handleInboundMessage(input);
+    strict_1.default.equal(sentThreadMessages.length, 1);
+    strict_1.default.match(sentThreadMessages[0] || '', /hello/);
+});
+(0, node_test_1.default)('weixin inbound messages create a chat binding when an authorized user has an old direct thread', async () => {
+    const bindings = [];
+    const sentThreadMessages = [];
+    const gateway = new local_core_weixin_gateway_js_1.LocalCoreWeixinGateway({
+        store: {
+            expirePendingPairings: () => { },
+            listPendingPairings: () => [],
+            listPairingRequests: () => [],
+            listAuthorizedUsers: () => [],
+            getAuthorizedUser: () => ({
+                id: 'auth-1',
+                workspace_id: 'default',
+                platform: 'weixin',
+                platform_user_id: 'user-1',
+                chat_id: 'old-direct-chat',
+                display_name: 'User',
+                thread_id: 'old-thread-1',
+            }),
+            getPlatformThreadBinding: () => undefined,
+            updateAuthorizedUserThread: () => { },
+            upsertPlatformThreadBinding: (binding) => bindings.push(binding),
+            updatePlatformThreadMessageId: (_workspaceId, _chatId, _platformUserId, messageId) => {
+                bindings[0] = { ...bindings[0], last_platform_message_id: messageId };
+            },
+            getLatestRunForThread: () => null,
+        },
+        readConfig: async () => ({
+            projects: [
+                {
+                    name: 'default',
+                    agent: { type: 'localcore-acp', providers: [] },
+                    platforms: [{ type: 'weixin', options: {} }],
+                },
+            ],
+        }),
+        getWorkspaceRouter: () => ({
+            createThread: async () => ({ id: 'group-thread-1' }),
+            getThreadSessionKey: (threadId) => `session:${threadId}`,
+            sendThreadMessage: async (threadId, text) => {
+                sentThreadMessages.push({ threadId, text });
+                return { runId: 'run-1' };
+            },
+        }),
+        eventBus: { emit: () => { }, on: () => () => { } },
+    });
+    await gateway.handleInboundMessage({
+        workspaceId: 'default',
+        platformUserId: 'user-1',
+        chatId: 'new-group-chat',
+        displayName: 'User',
+        text: 'hello',
+        messageId: 'msg-1',
+        contextToken: 'ctx-1',
+    });
+    strict_1.default.equal(bindings.length, 1);
+    strict_1.default.equal(bindings[0]?.platform, 'weixin');
+    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(bindings[0]?.last_platform_message_id, 'ctx-1');
+    strict_1.default.equal(sentThreadMessages[0]?.threadId, 'group-thread-1');
+    strict_1.default.match(sentThreadMessages[0]?.text || '', /hello/);
+});
+(0, node_test_1.default)('weixin downloaded file attachment becomes a structured file content part', () => {
+    const part = (0, local_core_weixin_gateway_js_1.createWeixinAttachmentContentPart)({
+        path: '/tmp/report.pdf',
+        kind: 'file',
+        name: 'report.pdf',
+    });
+    strict_1.default.deepEqual(part, {
+        type: 'file',
+        path: '/tmp/report.pdf',
+        fileName: 'report.pdf',
+    });
+});
+(0, node_test_1.default)('weixin downloaded image attachment keeps image data content part', () => {
+    const part = (0, local_core_weixin_gateway_js_1.createWeixinAttachmentContentPart)({
+        path: '/tmp/image.png',
+        kind: 'image',
+        name: 'image.png',
+        data: 'aW1n',
+        mimeType: 'image/png',
+    });
+    strict_1.default.deepEqual(part, {
+        type: 'image',
+        data: 'aW1n',
+        mimeType: 'image/png',
+        fileName: 'image.png',
+    });
+});
+(0, node_test_1.default)('weixin bridge skips duplicate rendered replies', async () => {
+    const originalFetch = globalThis.fetch;
+    const sentBodies = [];
+    globalThis.fetch = (async (_input, init) => {
+        sentBodies.push(JSON.parse(String(init?.body || '{}')));
+        return new Response(JSON.stringify({ errcode: 0 }), {
+            status: 200,
+            headers: { 'Content-Type': 'application/json' },
+        });
+    });
+    const gateway = new local_core_weixin_gateway_js_1.LocalCoreWeixinGateway({
+        store: {
+            getPlatformThreadBinding: () => ({
+                workspace_id: 'default',
+                platform: 'weixin',
+                chat_id: 'chat-1',
+                platform_user_id: 'user-1',
+                thread_id: 'thread-1',
+                last_platform_message_id: 'ctx-1',
+            }),
+        },
+        readConfig: async () => ({
+            projects: [
+                {
+                    name: 'default',
+                    agent: { type: 'localcore-acp', providers: [] },
+                    platforms: [{ type: 'weixin', options: { token: 'bot-token-1' } }],
+                },
+            ],
+        }),
+        getWorkspaceRouter: () => ({}),
+        eventBus: { emit: () => { }, on: () => () => { } },
+    });
+    const internals = gateway;
+    internals.runtime.set('default', {
+        workspaceId: 'default',
+        enabled: true,
+        status: 'running',
+        connected: true,
+        accountId: 'bot-1',
+    });
+    internals.threadRouting.set('session:thread-1', {
+        workspaceId: 'default',
+        platformUserId: 'user-1',
+        chatId: 'chat-1',
+        threadId: 'thread-1',
+    });
+    try {
+        await gateway.onBridgeEvent({ type: 'update_message', sessionKey: 'session:thread-1', content: 'same reply' });
+        await gateway.onBridgeEvent({ type: 'reply', sessionKey: 'session:thread-1', content: 'same reply' });
+        await gateway.onBridgeEvent({ type: 'typing_stop', sessionKey: 'session:thread-1' });
+        await gateway.onBridgeEvent({ type: 'reply', sessionKey: 'session:thread-1', content: 'same reply' });
+        strict_1.default.equal(sentBodies.length, 1);
+        strict_1.default.equal(sentBodies[0]?.msg?.item_list?.[0]?.text_item?.text, 'same reply');
+    }
+    finally {
+        globalThis.fetch = originalFetch;
+    }
+});
+(0, node_test_1.default)('weixin bridge keeps context replies to one truncated text message', async () => {
+    const originalFetch = globalThis.fetch;
+    const sentBodies = [];
+    globalThis.fetch = (async (_input, init) => {
+        sentBodies.push(JSON.parse(String(init?.body || '{}')));
+        return new Response(JSON.stringify({ errcode: 0 }), {
+            status: 200,
+            headers: { 'Content-Type': 'application/json' },
+        });
+    });
+    const gateway = new local_core_weixin_gateway_js_1.LocalCoreWeixinGateway({
+        store: {
+            getPlatformThreadBinding: () => ({
+                workspace_id: 'default',
+                platform: 'weixin',
+                chat_id: 'chat-1',
+                platform_user_id: 'user-1',
+                thread_id: 'thread-1',
+                last_platform_message_id: 'ctx-1',
+            }),
+        },
+        readConfig: async () => ({
+            projects: [
+                {
+                    name: 'default',
+                    agent: { type: 'localcore-acp', providers: [] },
+                    platforms: [{ type: 'weixin', options: { token: 'bot-token-1' } }],
+                },
+            ],
+        }),
+        getWorkspaceRouter: () => ({}),
+        eventBus: { emit: () => { }, on: () => () => { } },
+    });
+    const internals = gateway;
+    internals.runtime.set('default', {
+        workspaceId: 'default',
+        enabled: true,
+        status: 'running',
+        connected: true,
+        accountId: 'bot-1',
+    });
+    internals.threadRouting.set('session:thread-1', {
+        workspaceId: 'default',
+        platformUserId: 'user-1',
+        chatId: 'chat-1',
+        threadId: 'thread-1',
+    });
+    try {
+        await gateway.onBridgeEvent({
+            type: 'reply',
+            sessionKey: 'session:thread-1',
+            content: Array.from({ length: 80 }, (_, index) => `第 ${index + 1} 行：这是一段用于测试微信长文本切分的内容。`).join('\n\n'),
+        });
+        strict_1.default.equal(sentBodies.length, 1);
+        strict_1.default.equal(sentBodies[0]?.msg?.context_token, 'ctx-1');
+        for (const body of sentBodies) {
+            const text = body?.msg?.item_list?.[0]?.text_item?.text || '';
+            strict_1.default.ok(Buffer.byteLength(text, 'utf-8') <= 3500);
+            strict_1.default.match(text, /内容过长，已截断以保证微信送达/);
+            strict_1.default.equal(body?.base_info?.channel_version, '2.1.7');
+            strict_1.default.equal(body?.msg?.from_user_id, '');
+            strict_1.default.match(body?.msg?.client_id || '', /^openclaw-weixin-/);
+        }
+    }
+    finally {
+        globalThis.fetch = originalFetch;
+    }
+});
+(0, node_test_1.default)('weixin bridge sends protocol-compatible final reply payload', async () => {
+    const originalFetch = globalThis.fetch;
+    const sentRequests = [];
+    globalThis.fetch = (async (_input, init) => {
+        const body = JSON.parse(String(init?.body || '{}'));
+        sentRequests.push({ body, headers: new Headers(init?.headers) });
+        return new Response(JSON.stringify({ ret: 0 }), {
+            status: 200,
+            headers: { 'Content-Type': 'application/json' },
+        });
+    });
+    const gateway = new local_core_weixin_gateway_js_1.LocalCoreWeixinGateway({
+        store: {
+            getPlatformThreadBinding: () => ({
+                workspace_id: 'default',
+                platform: 'weixin',
+                chat_id: 'chat-1',
+                platform_user_id: 'user-1',
+                thread_id: 'thread-1',
+                last_platform_message_id: 'ctx-1',
+            }),
+        },
+        readConfig: async () => ({
+            projects: [
+                {
+                    name: 'default',
+                    agent: { type: 'localcore-acp', providers: [] },
+                    platforms: [{ type: 'weixin', options: { token: 'bot-token-1' } }],
+                },
+            ],
+        }),
+        getWorkspaceRouter: () => ({}),
+        eventBus: { emit: () => { }, on: () => () => { } },
+    });
+    const internals = gateway;
+    internals.runtime.set('default', {
+        workspaceId: 'default',
+        enabled: true,
+        status: 'running',
+        connected: true,
+        accountId: 'bot-1',
+    });
+    internals.threadRouting.set('session:thread-1', {
+        workspaceId: 'default',
+        platformUserId: 'user-1',
+        chatId: 'chat-1',
+        threadId: 'thread-1',
+    });
+    try {
+        await gateway.onBridgeEvent({ type: 'reply', sessionKey: 'session:thread-1', content: 'final reply' });
+        strict_1.default.equal(sentRequests.length, 1);
+        strict_1.default.equal(sentRequests[0]?.body?.msg?.context_token, 'ctx-1');
+        strict_1.default.equal(sentRequests[0]?.body?.msg?.from_user_id, '');
+        strict_1.default.equal(sentRequests[0]?.body?.msg?.message_state, 2);
+        strict_1.default.equal(sentRequests[0]?.body?.base_info?.channel_version, '2.1.7');
+        strict_1.default.match(sentRequests[0]?.body?.msg?.client_id || '', /^openclaw-weixin-/);
+        strict_1.default.equal(sentRequests[0]?.body?.msg?.item_list?.[0]?.text_item?.text, 'final reply');
+        strict_1.default.equal(sentRequests[0]?.headers.get('iLink-App-Id'), 'bot');
+        strict_1.default.equal(sentRequests[0]?.headers.get('iLink-App-ClientVersion'), '131335');
+        strict_1.default.equal(sentRequests[0]?.headers.get('AuthorizationType'), 'ilink_bot_token');
+        strict_1.default.equal(sentRequests[0]?.headers.get('Authorization'), 'Bearer bot-token-1');
+    }
+    finally {
+        globalThis.fetch = originalFetch;
+    }
+});
+(0, node_test_1.default)('weixin bridge sends status events in real time', async () => {
+    const originalFetch = globalThis.fetch;
+    const sentBodies = [];
+    globalThis.fetch = (async (_input, init) => {
+        sentBodies.push(JSON.parse(String(init?.body || '{}')));
+        return new Response(JSON.stringify({ ret: 0 }), {
+            status: 200,
+            headers: { 'Content-Type': 'application/json' },
+        });
+    });
+    const gateway = new local_core_weixin_gateway_js_1.LocalCoreWeixinGateway({
+        store: {
+            getPlatformThreadBinding: () => ({
+                workspace_id: 'default',
+                platform: 'weixin',
+                chat_id: 'chat-1',
+                platform_user_id: 'user-1',
+                thread_id: 'thread-1',
+                last_platform_message_id: 'ctx-1',
+            }),
+        },
+        readConfig: async () => ({
+            projects: [
+                {
+                    name: 'default',
+                    agent: { type: 'localcore-acp', providers: [] },
+                    platforms: [{ type: 'weixin', options: { token: 'bot-token-1' } }],
+                },
+            ],
+        }),
+        getWorkspaceRouter: () => ({}),
+        eventBus: { emit: () => { }, on: () => () => { } },
+    });
+    const internals = gateway;
+    internals.runtime.set('default', {
+        workspaceId: 'default',
+        enabled: true,
+        status: 'running',
+        connected: true,
+        accountId: 'bot-1',
+    });
+    internals.threadRouting.set('session:thread-1', {
+        workspaceId: 'default',
+        platformUserId: 'user-1',
+        chatId: 'chat-1',
+        threadId: 'thread-1',
+    });
+    try {
+        await gateway.onBridgeEvent({ type: 'status', sessionKey: 'session:thread-1', content: '正在检查桌面文件' });
+        strict_1.default.equal(sentBodies.length, 1);
+        strict_1.default.equal(sentBodies[0]?.msg?.context_token, 'ctx-1');
+        strict_1.default.equal(sentBodies[0]?.msg?.message_state, 2);
+        strict_1.default.equal(sentBodies[0]?.msg?.item_list?.[0]?.text_item?.text, '正在检查桌面文件');
+    }
+    finally {
+        globalThis.fetch = originalFetch;
+    }
+});
+(0, node_test_1.default)('weixin bridge sends tool progress in real time before final reply', async () => {
+    const originalFetch = globalThis.fetch;
+    const sentBodies = [];
+    globalThis.fetch = (async (_input, init) => {
+        sentBodies.push(JSON.parse(String(init?.body || '{}')));
+        return new Response(JSON.stringify({ ret: 0 }), {
+            status: 200,
+            headers: { 'Content-Type': 'application/json' },
+        });
+    });
+    const gateway = new local_core_weixin_gateway_js_1.LocalCoreWeixinGateway({
+        store: {
+            getPlatformThreadBinding: () => ({
+                workspace_id: 'default',
+                platform: 'weixin',
+                chat_id: 'chat-1',
+                platform_user_id: 'user-1',
+                thread_id: 'thread-1',
+                last_platform_message_id: 'ctx-1',
+            }),
+        },
+        readConfig: async () => ({
+            projects: [
+                {
+                    name: 'default',
+                    agent: { type: 'localcore-acp', providers: [] },
+                    platforms: [{ type: 'weixin', options: { token: 'bot-token-1' } }],
+                },
+            ],
+        }),
+        getWorkspaceRouter: () => ({}),
+        eventBus: { emit: () => { }, on: () => () => { } },
+    });
+    const internals = gateway;
+    internals.runtime.set('default', {
+        workspaceId: 'default',
+        enabled: true,
+        status: 'running',
+        connected: true,
+        accountId: 'bot-1',
+    });
+    internals.threadRouting.set('session:thread-1', {
+        workspaceId: 'default',
+        platformUserId: 'user-1',
+        chatId: 'chat-1',
+        threadId: 'thread-1',
+    });
+    try {
+        await gateway.onBridgeEvent({
+            type: 'reply',
+            sessionKey: 'session:thread-1',
+            bridgeKind: 'tool',
+            content: 'list desktop',
+            toolCall: {
+                name: 'list desktop',
+                status: 'running',
+                output: '',
+            },
+        });
+        await gateway.onBridgeEvent({ type: 'reply', sessionKey: 'session:thread-1', content: 'final reply' });
+        strict_1.default.equal(sentBodies.length, 2);
+        strict_1.default.equal(sentBodies[0]?.msg?.message_state, 2);
+        strict_1.default.equal(sentBodies[1]?.msg?.message_state, 2);
+        strict_1.default.equal(sentBodies[0]?.msg?.context_token, 'ctx-1');
+        strict_1.default.equal(sentBodies[1]?.msg?.context_token, 'ctx-1');
+        strict_1.default.equal(sentBodies[0]?.msg?.item_list?.[0]?.text_item?.text, '**处理中**\n• list desktop - running');
+        strict_1.default.equal(sentBodies[1]?.msg?.item_list?.[0]?.text_item?.text, 'final reply');
+    }
+    finally {
+        globalThis.fetch = originalFetch;
+    }
+});
+(0, node_test_1.default)('weixin bridge skips completed tool result updates but keeps final reply', async () => {
+    const originalFetch = globalThis.fetch;
+    const sentBodies = [];
+    globalThis.fetch = (async (_input, init) => {
+        sentBodies.push(JSON.parse(String(init?.body || '{}')));
+        return new Response(JSON.stringify({ errcode: 0 }), {
+            status: 200,
+            headers: { 'Content-Type': 'application/json' },
+        });
+    });
+    const gateway = new local_core_weixin_gateway_js_1.LocalCoreWeixinGateway({
+        store: {
+            getPlatformThreadBinding: () => ({
+                workspace_id: 'default',
+                platform: 'weixin',
+                chat_id: 'chat-1',
+                platform_user_id: 'user-1',
+                thread_id: 'thread-1',
+                last_platform_message_id: 'ctx-1',
+            }),
+        },
+        readConfig: async () => ({
+            projects: [
+                {
+                    name: 'default',
+                    agent: { type: 'localcore-acp', providers: [] },
+                    platforms: [{ type: 'weixin', options: { token: 'bot-token-1' } }],
+                },
+            ],
+        }),
+        getWorkspaceRouter: () => ({}),
+        eventBus: { emit: () => { }, on: () => () => { } },
+    });
+    const internals = gateway;
+    internals.runtime.set('default', {
+        workspaceId: 'default',
+        enabled: true,
+        status: 'running',
+        connected: true,
+        accountId: 'bot-1',
+    });
+    internals.threadRouting.set('session:thread-1', {
+        workspaceId: 'default',
+        platformUserId: 'user-1',
+        chatId: 'chat-1',
+        threadId: 'thread-1',
+    });
+    try {
+        await gateway.onBridgeEvent({
+            type: 'reply',
+            sessionKey: 'session:thread-1',
+            bridgeKind: 'tool',
+            content: 'Tool update completed',
+            toolCall: {
+                name: 'Tool update',
+                status: 'completed',
+                output: '/Users/mochuxian/Desktop has many files and this result should not be sent',
+            },
+        });
+        await gateway.onBridgeEvent({ type: 'reply', sessionKey: 'session:thread-1', content: 'final reply' });
+        strict_1.default.equal(sentBodies.length, 1);
+        strict_1.default.equal(sentBodies[0]?.msg?.message_state, 2);
+        strict_1.default.equal(sentBodies[0]?.msg?.item_list?.[0]?.text_item?.text, 'final reply');
+    }
+    finally {
+        globalThis.fetch = originalFetch;
+    }
+});
+(0, node_test_1.default)('weixin bridge keeps failed tool update status without execution details', async () => {
+    const originalFetch = globalThis.fetch;
+    const sentBodies = [];
+    globalThis.fetch = (async (_input, init) => {
+        sentBodies.push(JSON.parse(String(init?.body || '{}')));
+        return new Response(JSON.stringify({ errcode: 0 }), {
+            status: 200,
+            headers: { 'Content-Type': 'application/json' },
+        });
+    });
+    const gateway = new local_core_weixin_gateway_js_1.LocalCoreWeixinGateway({
+        store: {
+            getPlatformThreadBinding: () => ({
+                workspace_id: 'default',
+                platform: 'weixin',
+                chat_id: 'chat-1',
+                platform_user_id: 'user-1',
+                thread_id: 'thread-1',
+                last_platform_message_id: 'ctx-1',
+            }),
+        },
+        readConfig: async () => ({
+            projects: [
+                {
+                    name: 'default',
+                    agent: { type: 'localcore-acp', providers: [] },
+                    platforms: [{ type: 'weixin', options: { token: 'bot-token-1' } }],
+                },
+            ],
+        }),
+        getWorkspaceRouter: () => ({}),
+        eventBus: { emit: () => { }, on: () => () => { } },
+    });
+    const internals = gateway;
+    internals.runtime.set('default', {
+        workspaceId: 'default',
+        enabled: true,
+        status: 'running',
+        connected: true,
+        accountId: 'bot-1',
+    });
+    internals.threadRouting.set('session:thread-1', {
+        workspaceId: 'default',
+        platformUserId: 'user-1',
+        chatId: 'chat-1',
+        threadId: 'thread-1',
+    });
+    try {
+        await gateway.onBridgeEvent({
+            type: 'reply',
+            sessionKey: 'session:thread-1',
+            bridgeKind: 'tool',
+            content: 'Tool update failed',
+            toolCall: {
+                name: 'Tool update',
+                status: 'failed',
+                output: 'stack trace and command output should not be sent',
+            },
+        });
+        strict_1.default.equal(sentBodies.length, 1);
+        strict_1.default.equal(sentBodies[0]?.msg?.item_list?.[0]?.text_item?.text, '**处理中**\n• Tool update - failed');
+    }
+    finally {
+        globalThis.fetch = originalFetch;
+    }
+});
+(0, node_test_1.default)('weixin bridge folds progress after nine context sends and preserves final reply', async () => {
+    const originalFetch = globalThis.fetch;
+    const sentBodies = [];
+    globalThis.fetch = (async (_input, init) => {
+        sentBodies.push(JSON.parse(String(init?.body || '{}')));
+        return new Response(JSON.stringify({ ret: 0 }), {
+            status: 200,
+            headers: { 'Content-Type': 'application/json' },
+        });
+    });
+    const gateway = new local_core_weixin_gateway_js_1.LocalCoreWeixinGateway({
+        store: {
+            getPlatformThreadBinding: () => ({
+                workspace_id: 'default',
+                platform: 'weixin',
+                chat_id: 'chat-1',
+                platform_user_id: 'user-1',
+                thread_id: 'thread-1',
+                last_platform_message_id: 'ctx-1',
+            }),
+        },
+        readConfig: async () => ({
+            projects: [
+                {
+                    name: 'default',
+                    agent: { type: 'localcore-acp', providers: [] },
+                    platforms: [{ type: 'weixin', options: { token: 'bot-token-1' } }],
+                },
+            ],
+        }),
+        getWorkspaceRouter: () => ({}),
+        eventBus: { emit: () => { }, on: () => () => { } },
+    });
+    const internals = gateway;
+    internals.runtime.set('default', {
+        workspaceId: 'default',
+        enabled: true,
+        status: 'running',
+        connected: true,
+        accountId: 'bot-1',
+    });
+    internals.threadRouting.set('session:thread-1', {
+        workspaceId: 'default',
+        platformUserId: 'user-1',
+        chatId: 'chat-1',
+        threadId: 'thread-1',
+    });
+    try {
+        for (let index = 1; index <= 12; index += 1) {
+            await gateway.onBridgeEvent({
+                type: 'reply',
+                sessionKey: 'session:thread-1',
+                bridgeKind: 'status',
+                content: `🔧 tool ${index}`,
+            });
+        }
+        await gateway.onBridgeEvent({ type: 'reply', sessionKey: 'session:thread-1', content: 'final reply' });
+        strict_1.default.equal(sentBodies.length, 10);
+        strict_1.default.equal(sentBodies[0]?.msg?.item_list?.[0]?.text_item?.text, '**处理中**\n• 🔧 tool 1');
+        strict_1.default.match(sentBodies[8]?.msg?.item_list?.[0]?.text_item?.text, /🔧 tool 9/);
+        strict_1.default.doesNotMatch(sentBodies.map((body) => body?.msg?.item_list?.[0]?.text_item?.text || '').join('\n'), /🔧 tool 10|🔧 tool 11|🔧 tool 12/);
+        strict_1.default.match(sentBodies[9]?.msg?.item_list?.[0]?.text_item?.text, /已省略 3 条过程消息/);
+        strict_1.default.match(sentBodies[9]?.msg?.item_list?.[0]?.text_item?.text, /final reply/);
+    }
+    finally {
+        globalThis.fetch = originalFetch;
+    }
+});