aws-runtime-bridge 1.9.131 → 1.9.134

package/package/aws-client-agent-mcp/dist/websocket-client.test.js

@@ -1,725 +0,0 @@
-import { describe, it } from 'node:test';
-import assert from 'node:assert/strict';
-import { EventEmitter } from 'node:events';
-import { performance } from 'node:perf_hooks';
-import WebSocket from 'ws';
-import { WebSocketClient } from './websocket-client.js';
-class FakeSocket extends EventEmitter {
-    readyState;
-    sentPayloads = [];
-    constructor() {
-        super();
-        this.readyState = WebSocket.CONNECTING;
-    }
-    close() {
-        this.readyState = WebSocket.CLOSED;
-        this.emit('close', 1000, Buffer.from('manual close'));
-    }
-    terminate() {
-        this.readyState = WebSocket.CLOSED;
-    }
-    send(payload) {
-        this.sentPayloads.push(payload);
-    }
-    ping() {
-        setImmediate(() => this.emit('pong'));
-    }
-}
-class SilentPingSocket extends FakeSocket {
-    ping() {
-        // intentionally no pong
-    }
-    terminate() {
-        this.readyState = WebSocket.CLOSED;
-        this.emit('close', 1006, Buffer.from('heartbeat timeout'));
-    }
-}
-describe('WebSocketClient reconnect behavior', () => {
-    it('should include runtime token in websocket URL when configured', async () => {
-        let connectedUrl = '';
-        const client = new WebSocketClient({
-            serverUrl: 'ws://localhost:8080/ws/agent',
-            heartbeatInterval: 1000,
-            heartbeatTimeout: 3000,
-            reconnectInterval: 20,
-            maxReconnectAttempts: 1,
-            runtimeAccessToken: 'aws_rt_test_token',
-        }, (url) => {
-            connectedUrl = url;
-            const socket = new FakeSocket();
-            setImmediate(() => {
-                socket.readyState = WebSocket.OPEN;
-                socket.emit('open');
-            });
-            return socket;
-        });
-        try {
-            client.on('error', () => { });
-            await client.connect('agent-test');
-            const parsedUrl = new URL(connectedUrl);
-            assert.equal(parsedUrl.searchParams.get('agentId'), 'agent-test');
-            assert.equal(parsedUrl.searchParams.get('runtimeAccessToken'), 'aws_rt_test_token');
-        }
-        finally {
-            client.disconnect();
-        }
-    });
-    it('should force refresh runtime token once after policy rejection', async () => {
-        const requestedBodies = [];
-        const originalFetch = globalThis.fetch;
-        globalThis.fetch = (async (_url, init) => {
-            requestedBodies.push(JSON.parse(String(init?.body || '{}')));
-            return new Response(JSON.stringify({ ok: true, runtimeAccessToken: 'fresh-token' }), {
-                status: 200,
-                headers: { 'Content-Type': 'application/json' },
-            });
-        });
-        const connectedUrls = [];
-        let attempt = 0;
-        const client = new WebSocketClient({
-            serverUrl: 'ws://localhost:8080/ws/agent',
-            heartbeatInterval: 1000,
-            heartbeatTimeout: 3000,
-            reconnectInterval: 10,
-            reconnectJitterMs: 0,
-            maxReconnectAttempts: 2,
-            runtimeBridgeBaseUrl: 'http://127.0.0.1:18081',
-            userId: 'user-a',
-            runtimeAccessToken: 'stale-token',
-        }, (url) => {
-            connectedUrls.push(url);
-            attempt += 1;
-            const socket = new FakeSocket();
-            if (attempt === 1) {
-                setImmediate(() => {
-                    socket.readyState = WebSocket.OPEN;
-                    socket.emit('open');
-                    socket.readyState = WebSocket.CLOSED;
-                    socket.emit('close', 1008, Buffer.from('policy violation'));
-                });
-            }
-            else {
-                setImmediate(() => {
-                    socket.readyState = WebSocket.OPEN;
-                    socket.emit('open');
-                });
-            }
-            return socket;
-        });
-        try {
-            client.on('error', () => {
-                // suppress unhandled error event in test environment
-            });
-            await client.connect('agent-test');
-            await new Promise((resolve, reject) => {
-                const timer = setTimeout(() => reject(new Error('expected reconnect after token refresh')), 500);
-                client.on('connected', () => {
-                    if (attempt >= 2) {
-                        clearTimeout(timer);
-                        resolve();
-                    }
-                });
-            });
-            assert.equal(requestedBodies.length, 1);
-            assert.equal(requestedBodies[0]?.forceRefresh, true);
-            assert.equal(new URL(connectedUrls[0] || '').searchParams.get('runtimeAccessToken'), 'stale-token');
-            assert.equal(new URL(connectedUrls[1] || '').searchParams.get('runtimeAccessToken'), 'fresh-token');
-        }
-        finally {
-            client.disconnect();
-            globalThis.fetch = originalFetch;
-        }
-    });
-    it('should not hammer token refresh endpoint after repeated refresh failures', async () => {
-        let refreshRequests = 0;
-        const originalFetch = globalThis.fetch;
-        globalThis.fetch = (async () => {
-            refreshRequests += 1;
-            return new Response(JSON.stringify({ error: 'refresh failed' }), {
-                status: 500,
-                headers: { 'Content-Type': 'application/json' },
-            });
-        });
-        let attempt = 0;
-        const client = new WebSocketClient({
-            serverUrl: 'ws://localhost:8080/ws/agent',
-            heartbeatInterval: 1000,
-            heartbeatTimeout: 3000,
-            reconnectInterval: 10,
-            reconnectJitterMs: 0,
-            maxReconnectAttempts: 3,
-            runtimeBridgeBaseUrl: 'http://127.0.0.1:18081',
-            userId: 'user-a',
-            runtimeAccessToken: 'stale-token',
-        }, () => {
-            attempt += 1;
-            const socket = new FakeSocket();
-            setImmediate(() => {
-                socket.readyState = WebSocket.OPEN;
-                socket.emit('open');
-                socket.readyState = WebSocket.CLOSED;
-                socket.emit('close', 1008, Buffer.from('policy violation'));
-            });
-            return socket;
-        });
-        try {
-            client.on('error', () => {
-                // suppress unhandled error event in test environment
-            });
-            await client.connect('agent-test');
-            // 每次失败重连触发一次刷新；连续失败达到上限后不再高频重连/刷新。
-            // maxReconnectAttempts=3：3 次连接尝试 → 3 次 refresh → reconnectFailed 停止。
-            await new Promise((resolve, reject) => {
-                const timer = setTimeout(() => reject(new Error('expected reconnectFailed after refresh failures')), 1000);
-                client.on('reconnectFailed', () => {
-                    clearTimeout(timer);
-                    resolve();
-                });
-            });
-            // 停止后再观察一段窗口，确认没有继续 hammer 刷新接口
-            await new Promise((resolve) => setTimeout(resolve, 150));
-            assert.equal(attempt, 3, 'should stop reconnecting after refresh failures reach the limit');
-            assert.equal(refreshRequests, 3, 'one refresh per reconnect attempt, no extra hammering');
-        }
-        finally {
-            client.disconnect();
-            globalThis.fetch = originalFetch;
-        }
-    });
-    it('should keep slow-retrying after unchanged token refresh instead of giving up', async () => {
-        let refreshRequests = 0;
-        let tokenRejectedCount = 0;
-        const originalFetch = globalThis.fetch;
-        // bridge 始终返回与当前相同的 token（unchanged）：换 token 无法解决 1008
-        globalThis.fetch = (async () => {
-            refreshRequests += 1;
-            return new Response(JSON.stringify({ runtimeAccessToken: 'stale-token' }), {
-                status: 200,
-                headers: { 'Content-Type': 'application/json' },
-            });
-        });
-        let attempt = 0;
-        const client = new WebSocketClient({
-            serverUrl: 'ws://localhost:8080/ws/agent',
-            heartbeatInterval: 1000,
-            heartbeatTimeout: 3000,
-            reconnectInterval: 5,
-            reconnectJitterMs: 0,
-            maxReconnectAttempts: -1,
-            runtimeBridgeBaseUrl: 'http://127.0.0.1:18081',
-            userId: 'user-a',
-            runtimeAccessToken: 'stale-token',
-        }, () => {
-            attempt += 1;
-            const socket = new FakeSocket();
-            setImmediate(() => {
-                socket.readyState = WebSocket.OPEN;
-                socket.emit('open');
-                socket.readyState = WebSocket.CLOSED;
-                socket.emit('close', 1008, Buffer.from('policy violation'));
-            });
-            return socket;
-        });
-        try {
-            client.on('error', () => {
-                // suppress unhandled error event in test environment
-            });
-            client.on('tokenRejected', () => {
-                tokenRejectedCount += 1;
-            });
-            await client.connect('agent-test');
-            // 旧行为：unchanged 后永久放弃重连（Agent 永久离线）。
-            // 新行为：慢速重试持续进行——重连与刷新以退避节奏继续，等待新 token 签发自愈。
-            await new Promise((resolve, reject) => {
-                const timer = setTimeout(() => reject(new Error('expected continued slow retries after unchanged refresh')), 2000);
-                const check = setInterval(() => {
-                    if (attempt >= 4) {
-                        clearInterval(check);
-                        clearTimeout(timer);
-                        resolve();
-                    }
-                }, 5);
-            });
-            assert.ok(attempt >= 4, 'reconnect attempts should continue after unchanged refresh');
-            assert.ok(tokenRejectedCount >= 3, 'each 1008 rejection with unchanged token should be observable');
-            assert.ok(refreshRequests >= 3, 'refresh should keep being attempted at backoff cadence');
-        }
-        finally {
-            client.disconnect();
-            // close 事件处理链是 async（token 刷新 → 慢速重连排程），与 disconnect 存在竞态：
-            // 等在飞链路落定后再清一次，避免残留的长退避 timer 拖住测试进程
-            await new Promise((resolve) => setTimeout(resolve, 50));
-            client.disconnect();
-            globalThis.fetch = originalFetch;
-        }
-    });
-    it('should abort runtime token refresh after configured timeout', async () => {
-        const originalFetch = globalThis.fetch;
-        let signalSeen = false;
-        globalThis.fetch = (async (_url, init) => {
-            signalSeen = init?.signal instanceof AbortSignal;
-            return await new Promise((_resolve, reject) => {
-                init?.signal?.addEventListener('abort', () => reject(new Error('aborted by signal')), { once: true });
-            });
-        });
-        let attempt = 0;
-        const client = new WebSocketClient({
-            serverUrl: 'ws://localhost:8080/ws/agent',
-            heartbeatInterval: 1000,
-            heartbeatTimeout: 3000,
-            reconnectInterval: 10,
-            reconnectJitterMs: 0,
-            maxReconnectAttempts: 1,
-            runtimeBridgeBaseUrl: 'http://127.0.0.1:18081',
-            userId: 'user-a',
-            runtimeAccessToken: 'stale-token',
-            mcpHttpRequestTimeoutMs: 10,
-        }, () => {
-            attempt += 1;
-            const socket = new FakeSocket();
-            setImmediate(() => {
-                socket.readyState = WebSocket.OPEN;
-                socket.emit('open');
-                socket.readyState = WebSocket.CLOSED;
-                socket.emit('close', 1008, Buffer.from('policy violation'));
-            });
-            return socket;
-        });
-        try {
-            client.on('error', () => {
-                // suppress unhandled error event in test environment
-            });
-            await client.connect('agent-test');
-            await new Promise((resolve, reject) => {
-                const timer = setTimeout(() => reject(new Error('expected reconnect after refresh timeout')), 500);
-                client.on('disconnected', () => {
-                    if (attempt >= 2) {
-                        clearTimeout(timer);
-                        resolve();
-                    }
-                });
-            });
-            assert.equal(signalSeen, true);
-        }
-        finally {
-            client.disconnect();
-            globalThis.fetch = originalFetch;
-        }
-    });
-    it('should refresh again when a different runtime token is later rejected', async () => {
-        const requestedBodies = [];
-        const refreshedTokens = ['fresh-token-1', 'fresh-token-2'];
-        const originalFetch = globalThis.fetch;
-        globalThis.fetch = (async (_url, init) => {
-            requestedBodies.push(JSON.parse(String(init?.body || '{}')));
-            return new Response(JSON.stringify({ ok: true, runtimeAccessToken: refreshedTokens.shift() }), {
-                status: 200,
-                headers: { 'Content-Type': 'application/json' },
-            });
-        });
-        let attempt = 0;
-        const createdSockets = [];
-        const config = {
-            serverUrl: 'ws://localhost:8080/ws/agent',
-            heartbeatInterval: 1000,
-            heartbeatTimeout: 3000,
-            reconnectInterval: 10,
-            reconnectJitterMs: 0,
-            maxReconnectAttempts: 5,
-            runtimeBridgeBaseUrl: 'http://127.0.0.1:18081',
-            userId: 'user-a',
-            runtimeAccessToken: 'stale-token-1',
-        };
-        const client = new WebSocketClient(config, () => {
-            attempt += 1;
-            const socket = new FakeSocket();
-            createdSockets.push(socket);
-            setImmediate(() => {
-                socket.readyState = WebSocket.OPEN;
-                socket.emit('open');
-                if (attempt === 1) {
-                    socket.readyState = WebSocket.CLOSED;
-                    socket.emit('close', 1008, Buffer.from('policy violation'));
-                }
-            });
-            return socket;
-        });
-        try {
-            client.on('error', () => {
-                // suppress unhandled error event in test environment
-            });
-            await client.connect('agent-test');
-            await new Promise((resolve, reject) => {
-                const timer = setTimeout(() => reject(new Error('expected second token refresh')), 500);
-                const interval = setInterval(() => {
-                    if (requestedBodies.length >= 2 && config.runtimeAccessToken === 'fresh-token-2') {
-                        clearInterval(interval);
-                        clearTimeout(timer);
-                        resolve();
-                    }
-                }, 5);
-                client.on('connected', () => {
-                    if (attempt === 2) {
-                        config.runtimeAccessToken = 'stale-token-2';
-                        const activeSocket = createdSockets[createdSockets.length - 1];
-                        if (activeSocket) {
-                            activeSocket.readyState = WebSocket.CLOSED;
-                            activeSocket.emit('close', 1008, Buffer.from('policy violation'));
-                        }
-                    }
-                });
-            });
-            assert.equal(requestedBodies.length, 2);
-            assert.equal(config.runtimeAccessToken, 'fresh-token-2');
-        }
-        finally {
-            client.disconnect();
-            globalThis.fetch = originalFetch;
-        }
-    });
-    it('should keep retrying at interval after scheduler restart until connected', async () => {
-        const createdSockets = [];
-        let attempt = 0;
-        const client = new WebSocketClient({
-            serverUrl: 'ws://localhost:8080/ws/agent',
-            heartbeatInterval: 1000,
-            heartbeatTimeout: 3000,
-            reconnectInterval: 20,
-            reconnectJitterMs: 0,
-            maxReconnectAttempts: -1
-        }, (_url) => {
-            const socket = new FakeSocket();
-            createdSockets.push(socket);
-            attempt += 1;
-            if (attempt === 1 || attempt >= 4) {
-                setImmediate(() => {
-                    socket.readyState = WebSocket.OPEN;
-                    socket.emit('open');
-                });
-            }
-            else {
-                setImmediate(() => {
-                    socket.emit('error', new Error('ECONNREFUSED'));
-                    socket.emit('close', 1006, Buffer.from('connect fail'));
-                });
-            }
-            return socket;
-        });
-        try {
-            client.on('error', () => {
-                // suppress unhandled error event in test environment
-            });
-            await client.connect('agent-test');
-            const firstSocket = createdSockets[0];
-            assert.ok(firstSocket, 'first socket should exist');
-            firstSocket.readyState = WebSocket.CLOSED;
-            firstSocket.emit('close', 1006, Buffer.from('server restart'));
-            await new Promise((resolve, reject) => {
-                const timer = setTimeout(() => {
-                    reject(new Error('expected reconnect to eventually succeed'));
-                }, 500);
-                client.on('connected', () => {
-                    if (attempt >= 4) {
-                        clearTimeout(timer);
-                        resolve();
-                    }
-                });
-            });
-            assert.equal(attempt, 4, 'should attempt initial + retries until success');
-            assert.equal(client.isConnected(), true);
-        }
-        finally {
-            client.disconnect();
-        }
-    });
-    it('should wait reconnect interval before first reconnect attempt', async () => {
-        const reconnectInterval = 80;
-        const attemptTimes = [];
-        let attempt = 0;
-        const client = new WebSocketClient({
-            serverUrl: 'ws://localhost:8080/ws/agent',
-            heartbeatInterval: 1000,
-            heartbeatTimeout: 3000,
-            reconnectInterval,
-            reconnectJitterMs: 0,
-            maxReconnectAttempts: 2,
-        }, (_url) => {
-            const socket = new FakeSocket();
-            attempt += 1;
-            attemptTimes.push(performance.now());
-            if (attempt === 1) {
-                setImmediate(() => {
-                    socket.readyState = WebSocket.OPEN;
-                    socket.emit('open');
-                });
-            }
-            else {
-                setImmediate(() => {
-                    socket.readyState = WebSocket.OPEN;
-                    socket.emit('open');
-                });
-            }
-            return socket;
-        });
-        try {
-            client.on('error', () => {
-                // suppress unhandled error event in test environment
-            });
-            await client.connect('agent-test');
-            const firstSocketTime = attemptTimes[0];
-            const firstSocket = client.ws;
-            assert.ok(firstSocket, 'first socket should exist');
-            firstSocket.readyState = WebSocket.CLOSED;
-            firstSocket.emit('close', 1006, Buffer.from('server restart'));
-            await new Promise((resolve, reject) => {
-                const timer = setTimeout(() => {
-                    reject(new Error('expected reconnect attempt'));
-                }, 500);
-                const check = setInterval(() => {
-                    if (attempt >= 2) {
-                        clearInterval(check);
-                        clearTimeout(timer);
-                        resolve();
-                    }
-                }, 5);
-            });
-            assert.ok(attemptTimes[1] - firstSocketTime >= reconnectInterval - 15, `first reconnect should wait about ${reconnectInterval}ms, actual=${attemptTimes[1] - firstSocketTime}ms`);
-        }
-        finally {
-            client.disconnect();
-        }
-    });
-    it('should terminate and reconnect when heartbeat response times out', async () => {
-        const createdSockets = [];
-        let attempt = 0;
-        const client = new WebSocketClient({
-            serverUrl: 'ws://localhost:8080/ws/agent',
-            heartbeatInterval: 10,
-            heartbeatTimeout: 20,
-            reconnectInterval: 10,
-            reconnectJitterMs: 0,
-            maxReconnectAttempts: 2,
-        }, (_url) => {
-            attempt += 1;
-            const socket = attempt === 1 ? new SilentPingSocket() : new FakeSocket();
-            createdSockets.push(socket);
-            setImmediate(() => {
-                socket.readyState = WebSocket.OPEN;
-                socket.emit('open');
-            });
-            return socket;
-        });
-        try {
-            client.on('error', () => {
-                // suppress unhandled error event in test environment
-            });
-            await client.connect('agent-test');
-            await new Promise((resolve, reject) => {
-                const timer = setTimeout(() => {
-                    reject(new Error('expected reconnect after heartbeat timeout'));
-                }, 500);
-                client.on('connected', () => {
-                    if (attempt >= 2) {
-                        clearTimeout(timer);
-                        resolve();
-                    }
-                });
-            });
-            assert.equal(createdSockets[0]?.readyState, WebSocket.CLOSED);
-            assert.equal(attempt, 2);
-            assert.equal(client.isConnected(), true);
-        }
-        finally {
-            client.disconnect();
-        }
-    });
-    it('should acknowledge reliable direct messages when received', async () => {
-        const client = new WebSocketClient({
-            serverUrl: 'ws://localhost:8080/ws/agent',
-            heartbeatInterval: 1000,
-            heartbeatTimeout: 3000,
-            reconnectInterval: 20,
-            maxReconnectAttempts: 1,
-        }, (_url) => {
-            const socket = new FakeSocket();
-            setImmediate(() => {
-                socket.readyState = WebSocket.OPEN;
-                socket.emit('open');
-            });
-            return socket;
-        });
-        try {
-            client.on('error', () => {
-                // suppress unhandled error event in test environment
-            });
-            await client.connect('agent-test');
-            const socket = client.ws;
-            assert.ok(socket, 'socket should exist');
-            socket.emit('message', Buffer.from(JSON.stringify({
-                type: 'DM_MSG',
-                data: {
-                    msgId: 'dm-1',
-                    _msgId: 'delivery-1',
-                    _requireAck: true,
-                    senderId: 'agent-a',
-                    senderName: 'Agent A',
-                    receiverId: 'agent-test',
-                    content: 'hello',
-                    requireReply: false,
-                    timestamp: '2026-05-06T10:00:00.000Z',
-                },
-                timestamp: '2026-05-06T10:00:00.000Z',
-            })));
-            const ackPayload = socket.sentPayloads
-                .map(payload => JSON.parse(payload))
-                .find(payload => payload.type === 'MESSAGE_ACK');
-            assert.deepEqual(ackPayload, {
-                type: 'MESSAGE_ACK',
-                data: { msgId: 'delivery-1' },
-                timestamp: ackPayload?.timestamp,
-            });
-        }
-        finally {
-            client.disconnect();
-        }
-    });
-    it('should skip duplicate reliable messages but still ACK them', async () => {
-        const directMessageCalls = [];
-        const client = new WebSocketClient({
-            serverUrl: 'ws://localhost:8080/ws/agent',
-            heartbeatInterval: 1000,
-            heartbeatTimeout: 3000,
-            reconnectInterval: 20,
-            maxReconnectAttempts: 1,
-        }, (_url) => {
-            const socket = new FakeSocket();
-            setImmediate(() => {
-                socket.readyState = WebSocket.OPEN;
-                socket.emit('open');
-            });
-            return socket;
-        });
-        try {
-            client.on('error', () => { });
-            client.on('directMessage', (data) => {
-                directMessageCalls.push(data);
-            });
-            await client.connect('agent-test');
-            const socket = client.ws;
-            assert.ok(socket, 'socket should exist');
-            const buildPayload = () => JSON.stringify({
-                type: 'DM_MSG',
-                data: {
-                    msgId: 'dm-dup-1',
-                    _msgId: 'delivery-dup-1',
-                    _requireAck: true,
-                    senderId: 'agent-a',
-                    senderName: 'Agent A',
-                    receiverId: 'agent-test',
-                    content: 'hello',
-                    requireReply: false,
-                    timestamp: '2026-05-06T10:00:00.000Z',
-                },
-                timestamp: '2026-05-06T10:00:00.000Z',
-            });
-            // 模拟服务端 ACK 超时后重发同一 messageId
-            socket.emit('message', Buffer.from(buildPayload()));
-            socket.emit('message', Buffer.from(buildPayload()));
-            const ackPayloads = socket.sentPayloads
-                .map(payload => JSON.parse(payload))
-                .filter(payload => payload.type === 'MESSAGE_ACK' && payload.data?.msgId === 'delivery-dup-1');
-            // 重复投递的消息仍需回 ACK，避免服务端继续重试堆积
-            assert.equal(ackPayloads.length, 2, 'should ACK both first and duplicate delivery');
-            // 业务侧只能收到一次
-            assert.equal(directMessageCalls.length, 1, 'should deliver duplicate message to handler only once');
-        }
-        finally {
-            client.disconnect();
-        }
-    });
-    it('should ignore terminal status messages without warning', async () => {
-        const originalWarn = console.warn;
-        const warnMessages = [];
-        console.warn = (...args) => {
-            warnMessages.push(args.map(String).join(' '));
-        };
-        const client = new WebSocketClient({
-            serverUrl: 'ws://localhost:8080/ws/agent',
-            heartbeatInterval: 1000,
-            heartbeatTimeout: 3000,
-            reconnectInterval: 20,
-            maxReconnectAttempts: 1,
-        }, (_url) => {
-            const socket = new FakeSocket();
-            setImmediate(() => {
-                socket.readyState = WebSocket.OPEN;
-                socket.emit('open');
-            });
-            return socket;
-        });
-        try {
-            client.on('error', () => {
-                // suppress unhandled error event in test environment
-            });
-            await client.connect('agent-test');
-            const socket = client.ws;
-            assert.ok(socket, 'socket should exist');
-            socket.emit('message', Buffer.from(JSON.stringify({
-                type: 'TERMINAL_STATUS',
-                data: {
-                    agentId: 'agent-test',
-                    status: 'running',
-                    sessionId: 'session-1',
-                },
-                timestamp: '2026-05-06T10:00:00.000Z',
-            })));
-            assert.equal(warnMessages.some(message => message.includes('未知消息类型')), false);
-        }
-        finally {
-            client.disconnect();
-            console.warn = originalWarn;
-        }
-    });
-    it('should ignore MCP node log broadcasts without warning', async () => {
-        const originalWarn = console.warn;
-        const warnMessages = [];
-        console.warn = (...args) => {
-            warnMessages.push(args.map(String).join(' '));
-        };
-        const client = new WebSocketClient({
-            serverUrl: 'ws://localhost:8080/ws/agent',
-            heartbeatInterval: 1000,
-            heartbeatTimeout: 3000,
-            reconnectInterval: 20,
-            maxReconnectAttempts: 1,
-        }, (_url) => {
-            const socket = new FakeSocket();
-            setImmediate(() => {
-                socket.readyState = WebSocket.OPEN;
-                socket.emit('open');
-            });
-            return socket;
-        });
-        try {
-            client.on('error', () => { });
-            await client.connect('agent-test');
-            const socket = client.ws;
-            assert.ok(socket, 'socket should exist');
-            socket.emit('message', Buffer.from(JSON.stringify({
-                type: 'MCP_NODE_LOG',
-                data: {
-                    agentId: 'agent-test',
-                    level: 'info',
-                    message: 'AI request started',
-                    timestamp: 1_780_000_000_000,
-                },
-                timestamp: '2026-05-06T10:00:00.000Z',
-            })));
-            assert.equal(warnMessages.some(message => message.includes('MCP_NODE_LOG')), false);
-        }
-        finally {
-            client.disconnect();
-            console.warn = originalWarn;
-        }
-    });
-});