@openclaw-cloud/agent-controller 0.2.6 → 0.2.7

package/__tests__/gateway-adapter.test.ts

@@ -1,366 +0,0 @@
-// Mock GatewayClient before importing gateway-adapter
-jest.mock('../src/openclaw/gateway-client');
-
-import { GatewayClient } from '../src/openclaw/gateway-client';
-import { OpenclawGatewayAdapter } from '../src/openclaw/gateway-adapter';
-
-const MockGatewayClient = GatewayClient as jest.MockedClass<typeof GatewayClient>;
-
-type EventHandler = (event: { event: string; payload: any }) => void;
-
-function makeAdapter(): {
-  adapter: OpenclawGatewayAdapter;
-  mock: jest.Mocked<GatewayClient>;
-  simulateStreamEvent: (payload: Record<string, unknown>) => void;
-} {
-  const mock: jest.Mocked<GatewayClient> = {
-    connect: jest.fn().mockResolvedValue(undefined),
-    disconnect: jest.fn(),
-    isConnected: jest.fn().mockReturnValue(false),
-    request: jest.fn().mockResolvedValue(undefined),
-    setEventHandler: jest.fn(),
-  } as unknown as jest.Mocked<GatewayClient>;
-
-  MockGatewayClient.mockImplementation(() => mock);
-
-  const adapter = new OpenclawGatewayAdapter('ws://localhost', 'token');
-
-  // Capture the event handler registered in the constructor
-  const capturedHandler: EventHandler = mock.setEventHandler.mock.calls[0][0];
-
-  return {
-    adapter,
-    mock,
-    simulateStreamEvent: (payload) => capturedHandler({ event: 'chat.stream', payload }),
-  };
-}
-
-beforeEach(() => {
-  jest.clearAllMocks();
-  MockGatewayClient.mockClear();
-});
-
-describe('OpenclawGatewayAdapter – construction', () => {
-  it('creates a GatewayClient and registers an event handler', () => {
-    const { mock } = makeAdapter();
-    expect(MockGatewayClient).toHaveBeenCalledTimes(1);
-    expect(mock.setEventHandler).toHaveBeenCalledTimes(1);
-    expect(mock.setEventHandler).toHaveBeenCalledWith(expect.any(Function));
-  });
-});
-
-describe('OpenclawGatewayAdapter – isConnected()', () => {
-  it('delegates to GatewayClient.isConnected()', () => {
-    const { adapter, mock } = makeAdapter();
-    mock.isConnected.mockReturnValueOnce(false);
-    expect(adapter.isConnected()).toBe(false);
-    mock.isConnected.mockReturnValueOnce(true);
-    expect(adapter.isConnected()).toBe(true);
-  });
-});
-
-describe('OpenclawGatewayAdapter – connect()', () => {
-  it('delegates to GatewayClient.connect()', async () => {
-    const { adapter, mock } = makeAdapter();
-    await adapter.connect();
-    expect(mock.connect).toHaveBeenCalledTimes(1);
-  });
-
-  it('propagates rejection from GatewayClient.connect()', async () => {
-    const { adapter, mock } = makeAdapter();
-    mock.connect.mockRejectedValue(new Error('ECONNREFUSED'));
-    await expect(adapter.connect()).rejects.toThrow('ECONNREFUSED');
-  });
-});
-
-describe('OpenclawGatewayAdapter – disconnect()', () => {
-  it('delegates to GatewayClient.disconnect()', () => {
-    const { adapter, mock } = makeAdapter();
-    adapter.disconnect();
-    expect(mock.disconnect).toHaveBeenCalledTimes(1);
-  });
-});
-
-describe('OpenclawGatewayAdapter – listSessions()', () => {
-  it('calls request("sessions.list", {}) and maps result', async () => {
-    const { adapter, mock } = makeAdapter();
-    mock.request.mockResolvedValue({
-      sessions: [
-        { key: 's1', sessionId: 'sid-1', kind: 'direct', updatedAt: 1000, model: 'claude-3' },
-        { key: 's2', sessionId: 'sid-2', kind: 'project', updatedAt: 2000 },
-      ],
-    });
-
-    const result = await adapter.listSessions();
-
-    expect(mock.request).toHaveBeenCalledWith('sessions.list', {});
-    expect(result).toHaveLength(2);
-    expect(result[0]).toMatchObject({ key: 's1', sessionId: 'sid-1', kind: 'direct', updatedAt: 1000, model: 'claude-3' });
-    expect(result[1]).toMatchObject({ key: 's2', sessionId: 'sid-2', kind: 'project', updatedAt: 2000 });
-  });
-
-  it('uses default values for missing session fields', async () => {
-    const { adapter, mock } = makeAdapter();
-    mock.request.mockResolvedValue({ sessions: [{ key: 'k1' }] });
-
-    const result = await adapter.listSessions();
-
-    expect(result[0]).toMatchObject({ key: 'k1', sessionId: '', kind: 'direct', updatedAt: 0 });
-  });
-
-  it('returns [] when result is null', async () => {
-    const { adapter, mock } = makeAdapter();
-    mock.request.mockResolvedValue(null);
-
-    const result = await adapter.listSessions();
-    expect(result).toEqual([]);
-  });
-
-  it('returns [] when sessions field is missing', async () => {
-    const { adapter, mock } = makeAdapter();
-    mock.request.mockResolvedValue({});
-
-    const result = await adapter.listSessions();
-    expect(result).toEqual([]);
-  });
-});
-
-describe('OpenclawGatewayAdapter – getHistory()', () => {
-  it('calls request("chat.history") with sessionKey and default limit 200', async () => {
-    const { adapter, mock } = makeAdapter();
-    mock.request.mockResolvedValue({ messages: [] });
-
-    await adapter.getHistory('sess-1');
-
-    expect(mock.request).toHaveBeenCalledWith('chat.history', { sessionKey: 'sess-1', limit: 200 });
-  });
-
-  it('passes custom limit when provided', async () => {
-    const { adapter, mock } = makeAdapter();
-    mock.request.mockResolvedValue({ messages: [] });
-
-    await adapter.getHistory('sess-1', 50);
-
-    expect(mock.request).toHaveBeenCalledWith('chat.history', { sessionKey: 'sess-1', limit: 50 });
-  });
-
-  it('filters out system and tool messages', async () => {
-    const { adapter, mock } = makeAdapter();
-    mock.request.mockResolvedValue({
-      messages: [
-        { role: 'user', content: 'hello', timestamp: '2026-01-01T00:00:00Z' },
-        { role: 'system', content: 'ignored' },
-        { role: 'assistant', content: 'hi', timestamp: '2026-01-01T00:00:01Z' },
-        { role: 'tool', content: 'ignored' },
-      ],
-    });
-
-    const result = await adapter.getHistory('sess-1');
-
-    expect(result).toHaveLength(2);
-    expect(result[0].role).toBe('user');
-    expect(result[1].role).toBe('assistant');
-  });
-
-  it('concatenates text blocks when content is an array', async () => {
-    const { adapter, mock } = makeAdapter();
-    mock.request.mockResolvedValue({
-      messages: [
-        {
-          role: 'user',
-          content: [
-            { type: 'text', text: 'foo' },
-            { type: 'image', data: 'ignored' },
-            { type: 'text', text: 'bar' },
-          ],
-          timestamp: 0,
-        },
-      ],
-    });
-
-    const result = await adapter.getHistory('sess-1');
-    expect(result[0].content).toBe('foobar');
-  });
-
-  it('uses string content directly', async () => {
-    const { adapter, mock } = makeAdapter();
-    mock.request.mockResolvedValue({
-      messages: [{ role: 'user', content: 'plain text', timestamp: '2026-01-01T00:00:00Z' }],
-    });
-
-    const result = await adapter.getHistory('sess-1');
-    expect(result[0].content).toBe('plain text');
-  });
-
-  it('converts numeric timestamp to ISO string', async () => {
-    const { adapter, mock } = makeAdapter();
-    const ts = Date.UTC(2026, 0, 1, 12, 0, 0);
-    mock.request.mockResolvedValue({
-      messages: [{ role: 'user', content: 'hi', timestamp: ts }],
-    });
-
-    const result = await adapter.getHistory('sess-1');
-    expect(result[0].timestamp).toBe(new Date(ts).toISOString());
-  });
-
-  it('returns [] when result is null', async () => {
-    const { adapter, mock } = makeAdapter();
-    mock.request.mockResolvedValue(null);
-
-    const result = await adapter.getHistory('sess-1');
-    expect(result).toEqual([]);
-  });
-});
-
-describe('OpenclawGatewayAdapter – sendMessage()', () => {
-  it('sends chat.send request with correct payload', async () => {
-    const { adapter, mock } = makeAdapter();
-    mock.request.mockResolvedValue(undefined);
-
-    await adapter.sendMessage({ sessionKey: 'sess-1', text: 'hello', idempotencyKey: 'idem-1' });
-
-    expect(mock.request).toHaveBeenCalledWith('chat.send', {
-      sessionKey: 'sess-1',
-      message: 'hello',
-      deliver: false,
-      idempotencyKey: 'idem-1',
-    });
-  });
-
-  it('includes attachments in payload when provided', async () => {
-    const { adapter, mock } = makeAdapter();
-    mock.request.mockResolvedValue(undefined);
-    const attachments = [{ type: 'image' as const, mimeType: 'image/png', content: 'base64data' }];
-
-    await adapter.sendMessage({ sessionKey: 'sess-1', text: 'hi', idempotencyKey: 'k1', attachments });
-
-    const [, payload] = mock.request.mock.calls[0] as [string, any];
-    expect(payload.attachments).toEqual(attachments);
-  });
-
-  it('omits attachments field when not provided', async () => {
-    const { adapter, mock } = makeAdapter();
-    mock.request.mockResolvedValue(undefined);
-
-    await adapter.sendMessage({ sessionKey: 'sess-1', text: 'hi', idempotencyKey: 'k1' });
-
-    const [, payload] = mock.request.mock.calls[0] as [string, any];
-    expect(payload.attachments).toBeUndefined();
-  });
-
-  it('calls onError and removes callback when request throws', async () => {
-    const { adapter, mock } = makeAdapter();
-    mock.request.mockRejectedValue(new Error('network fail'));
-    const onError = jest.fn();
-
-    await adapter.sendMessage({ sessionKey: 'sess-1', text: 'hi', idempotencyKey: 'k1', onError });
-
-    expect(onError).toHaveBeenCalledWith('network fail');
-  });
-
-  it('calls onDelta when delta stream event arrives', async () => {
-    const { adapter, mock, simulateStreamEvent } = makeAdapter();
-    mock.request.mockResolvedValue(undefined);
-    const onDelta = jest.fn();
-
-    await adapter.sendMessage({ sessionKey: 'sess-1', text: 'hi', idempotencyKey: 'k1', onDelta });
-    simulateStreamEvent({ sessionKey: 'sess-1', runId: 'k1', state: 'delta', message: 'partial text' });
-
-    expect(onDelta).toHaveBeenCalledWith('partial text');
-  });
-
-  it('calls onDone with accumulated text on final event', async () => {
-    const { adapter, mock, simulateStreamEvent } = makeAdapter();
-    mock.request.mockResolvedValue(undefined);
-    const onDone = jest.fn();
-
-    await adapter.sendMessage({ sessionKey: 'sess-1', text: 'hi', idempotencyKey: 'k1', onDone });
-    simulateStreamEvent({ sessionKey: 'sess-1', runId: 'k1', state: 'delta', message: 'full text' });
-    simulateStreamEvent({ sessionKey: 'sess-1', runId: 'k1', state: 'final' });
-
-    expect(onDone).toHaveBeenCalledWith('full text');
-  });
-
-  it('calls onDone on aborted event with last accumulated text', async () => {
-    const { adapter, mock, simulateStreamEvent } = makeAdapter();
-    mock.request.mockResolvedValue(undefined);
-    const onDone = jest.fn();
-
-    await adapter.sendMessage({ sessionKey: 'sess-1', text: 'hi', idempotencyKey: 'k1', onDone });
-    simulateStreamEvent({ sessionKey: 'sess-1', runId: 'k1', state: 'delta', message: 'partial' });
-    simulateStreamEvent({ sessionKey: 'sess-1', runId: 'k1', state: 'aborted' });
-
-    expect(onDone).toHaveBeenCalledWith('partial');
-  });
-
-  it('calls onError when error stream event arrives with string error', async () => {
-    const { adapter, mock, simulateStreamEvent } = makeAdapter();
-    mock.request.mockResolvedValue(undefined);
-    const onError = jest.fn();
-
-    await adapter.sendMessage({ sessionKey: 'sess-1', text: 'hi', idempotencyKey: 'k1', onError });
-    simulateStreamEvent({ sessionKey: 'sess-1', runId: 'k1', state: 'error', error: 'stream error' });
-
-    expect(onError).toHaveBeenCalledWith('stream error');
-  });
-
-  it('calls onError with error.message when error is an object', async () => {
-    const { adapter, mock, simulateStreamEvent } = makeAdapter();
-    mock.request.mockResolvedValue(undefined);
-    const onError = jest.fn();
-
-    await adapter.sendMessage({ sessionKey: 'sess-1', text: 'hi', idempotencyKey: 'k1', onError });
-    simulateStreamEvent({ sessionKey: 'sess-1', runId: 'k1', state: 'error', error: { message: 'obj error' } });
-
-    expect(onError).toHaveBeenCalledWith('obj error');
-  });
-
-  it('ignores stream events with unknown runId', async () => {
-    const { adapter, mock, simulateStreamEvent } = makeAdapter();
-    mock.request.mockResolvedValue(undefined);
-    const onDelta = jest.fn();
-
-    await adapter.sendMessage({ sessionKey: 'sess-1', text: 'hi', idempotencyKey: 'k1', onDelta });
-    simulateStreamEvent({ sessionKey: 'sess-1', runId: 'unknown-id', state: 'delta', message: 'x' });
-
-    expect(onDelta).not.toHaveBeenCalled();
-  });
-
-  it('ignores events with missing sessionKey in payload', async () => {
-    const { adapter, mock, simulateStreamEvent } = makeAdapter();
-    mock.request.mockResolvedValue(undefined);
-    const onDelta = jest.fn();
-
-    await adapter.sendMessage({ sessionKey: 'sess-1', text: 'hi', idempotencyKey: 'k1', onDelta });
-    simulateStreamEvent({ runId: 'k1', state: 'delta', message: 'x' } as any);
-
-    expect(onDelta).not.toHaveBeenCalled();
-  });
-});
-
-describe('OpenclawGatewayAdapter – abort()', () => {
-  it('calls chat.abort with sessionKey and runId', async () => {
-    const { adapter, mock } = makeAdapter();
-    mock.request.mockResolvedValue(undefined);
-
-    await adapter.abort('sess-1', 'run-1');
-
-    expect(mock.request).toHaveBeenCalledWith('chat.abort', { sessionKey: 'sess-1', runId: 'run-1' });
-  });
-
-  it('calls chat.abort without runId when not provided', async () => {
-    const { adapter, mock } = makeAdapter();
-    mock.request.mockResolvedValue(undefined);
-
-    await adapter.abort('sess-1');
-
-    expect(mock.request).toHaveBeenCalledWith('chat.abort', { sessionKey: 'sess-1', runId: undefined });
-  });
-
-  it('does not throw when request rejects', async () => {
-    const { adapter, mock } = makeAdapter();
-    mock.request.mockRejectedValue(new Error('abort failed'));
-
-    await expect(adapter.abort('sess-1', 'run-1')).resolves.toBeUndefined();
-  });
-});

package/__tests__/gateway-client.test.ts

@@ -1,272 +0,0 @@
-// Mock ws before importing anything that uses it.
-// The 'instances' array lives inside the factory closure and is exposed via the
-// static property so tests can grab the last created socket.
-jest.mock('ws', () => {
-  const { EventEmitter } = require('node:events');
-  const instances: any[] = [];
-
-  class MockWebSocket extends EventEmitter {
-    static OPEN = 1;
-    static instances = instances;
-    readyState = 1;
-    send = jest.fn();
-    close = jest.fn(() => (this as any).emit('close'));
-
-    constructor() {
-      super();
-      instances.push(this);
-    }
-  }
-
-  return MockWebSocket;
-});
-
-import WebSocket from 'ws';
-import { GatewayClient } from '../src/openclaw/gateway-client';
-
-const WS = WebSocket as any;
-
-function lastWs(): any {
-  return WS.instances[WS.instances.length - 1];
-}
-
-// Complete the connect handshake (challenge → auth → resolve).
-async function doConnect(client: GatewayClient): Promise<any> {
-  const connectPromise = client.connect();
-  const ws = lastWs();
-
-  ws.emit('message', JSON.stringify({ type: 'event', event: 'connect.challenge', payload: {} }));
-  await Promise.resolve(); // let the async handler send the auth request
-
-  const sent = JSON.parse(ws.send.mock.calls[0][0]);
-  ws.emit('message', JSON.stringify({ type: 'res', id: sent.id, ok: true, payload: {} }));
-  await connectPromise;
-
-  ws.send.mockClear();
-  return ws;
-}
-
-beforeEach(() => {
-  WS.instances.length = 0;
-  jest.clearAllMocks();
-});
-
-describe('GatewayClient – initial state', () => {
-  it('is not connected before connect()', () => {
-    const client = new GatewayClient('ws://localhost', 'token');
-    expect(client.isConnected()).toBe(false);
-  });
-
-  it('setEventHandler does not throw', () => {
-    const client = new GatewayClient('ws://localhost', 'token');
-    expect(() => client.setEventHandler(jest.fn())).not.toThrow();
-  });
-});
-
-describe('GatewayClient – request() before connect', () => {
-  it('rejects with "Not connected" when ws is null', async () => {
-    const client = new GatewayClient('ws://localhost', 'token');
-    await expect(client.request('test', {})).rejects.toThrow('Not connected');
-  });
-});
-
-describe('GatewayClient – disconnect()', () => {
-  it('is safe to call when not connected', () => {
-    const client = new GatewayClient('ws://localhost', 'token');
-    expect(() => client.disconnect()).not.toThrow();
-  });
-
-  it('marks client as not connected after connect → disconnect', async () => {
-    const client = new GatewayClient('ws://localhost', 'token');
-    await doConnect(client);
-
-    expect(client.isConnected()).toBe(true);
-    client.disconnect();
-    expect(client.isConnected()).toBe(false);
-  });
-
-  it('rejects pending requests on disconnect', async () => {
-    const client = new GatewayClient('ws://localhost', 'token');
-    const ws = await doConnect(client);
-
-    const pending = client.request('slow.method', {});
-    client.disconnect();
-
-    await expect(pending).rejects.toThrow('Connection closed');
-  });
-});
-
-describe('GatewayClient – connect()', () => {
-  it('creates WebSocket with the given url', async () => {
-    const client = new GatewayClient('ws://test-host:8000', 'tok');
-    await doConnect(client);
-    expect(WS.instances).toHaveLength(1);
-  });
-
-  it('sends auth request containing the token after connect.challenge', async () => {
-    const client = new GatewayClient('ws://localhost', 'secret-token');
-    const connectPromise = client.connect();
-    const ws = lastWs();
-
-    ws.emit('message', JSON.stringify({ type: 'event', event: 'connect.challenge', payload: {} }));
-    await Promise.resolve();
-
-    expect(ws.send).toHaveBeenCalledTimes(1);
-    const msg = JSON.parse(ws.send.mock.calls[0][0]);
-    expect(msg.method).toBe('connect');
-    expect(msg.params.auth.token).toBe('secret-token');
-    expect(msg.type).toBe('req');
-
-    ws.emit('message', JSON.stringify({ type: 'res', id: msg.id, ok: true, payload: {} }));
-    await connectPromise;
-  });
-
-  it('resolves and sets isConnected to true after successful auth', async () => {
-    const client = new GatewayClient('ws://localhost', 'token');
-    await doConnect(client);
-    expect(client.isConnected()).toBe(true);
-  });
-
-  it('rejects when WebSocket emits error before connecting', async () => {
-    const client = new GatewayClient('ws://localhost', 'token');
-    const connectPromise = client.connect();
-    lastWs().emit('error', new Error('ECONNREFUSED'));
-    await expect(connectPromise).rejects.toThrow('ECONNREFUSED');
-  });
-
-  it('rejects when auth response is an error', async () => {
-    const client = new GatewayClient('ws://localhost', 'token');
-    const connectPromise = client.connect();
-    const ws = lastWs();
-
-    ws.emit('message', JSON.stringify({ type: 'event', event: 'connect.challenge', payload: {} }));
-    await Promise.resolve();
-
-    const msg = JSON.parse(ws.send.mock.calls[0][0]);
-    ws.emit('message', JSON.stringify({ type: 'res', id: msg.id, ok: false, error: { message: 'Unauthorized' } }));
-
-    await expect(connectPromise).rejects.toThrow('Unauthorized');
-  });
-
-  it('ignores events other than connect.challenge during handshake', async () => {
-    const client = new GatewayClient('ws://localhost', 'token');
-    const connectPromise = client.connect();
-    const ws = lastWs();
-
-    ws.emit('message', JSON.stringify({ type: 'event', event: 'other.event', payload: {} }));
-    await Promise.resolve();
-    expect(ws.send).not.toHaveBeenCalled();
-
-    ws.emit('message', JSON.stringify({ type: 'event', event: 'connect.challenge', payload: {} }));
-    await Promise.resolve();
-    expect(ws.send).toHaveBeenCalledTimes(1);
-
-    const msg = JSON.parse(ws.send.mock.calls[0][0]);
-    ws.emit('message', JSON.stringify({ type: 'res', id: msg.id, ok: true, payload: {} }));
-    await connectPromise;
-  });
-
-  it('restores original event handler after auth completes', async () => {
-    const originalHandler = jest.fn();
-    const client = new GatewayClient('ws://localhost', 'token');
-    client.setEventHandler(originalHandler);
-    const ws = await doConnect(client);
-
-    // Post-connect event should reach the original handler
-    ws.emit('message', JSON.stringify({ type: 'event', event: 'some.event', payload: { x: 1 } }));
-    await Promise.resolve();
-
-    expect(originalHandler).toHaveBeenCalledWith(expect.objectContaining({ event: 'some.event' }));
-  });
-});
-
-describe('GatewayClient – request() after connect', () => {
-  it('sends request with correct type, method, params, and id fields', async () => {
-    const client = new GatewayClient('ws://localhost', 'token');
-    const ws = await doConnect(client);
-
-    const reqPromise = client.request('sessions.list', { limit: 10 });
-    expect(ws.send).toHaveBeenCalledTimes(1);
-
-    const sent = JSON.parse(ws.send.mock.calls[0][0]);
-    expect(sent.type).toBe('req');
-    expect(sent.method).toBe('sessions.list');
-    expect(sent.params).toEqual({ limit: 10 });
-    expect(typeof sent.id).toBe('string');
-
-    ws.emit('message', JSON.stringify({ type: 'res', id: sent.id, ok: true, payload: { sessions: [] } }));
-    const result = await reqPromise;
-    expect(result.sessions).toEqual([]);
-  });
-
-  it('rejects when response has ok:false', async () => {
-    const client = new GatewayClient('ws://localhost', 'token');
-    const ws = await doConnect(client);
-
-    const reqPromise = client.request('sessions.list', {});
-    const sent = JSON.parse(ws.send.mock.calls[0][0]);
-    ws.emit('message', JSON.stringify({ type: 'res', id: sent.id, ok: false, error: { message: 'Not found' } }));
-
-    await expect(reqPromise).rejects.toThrow('Not found');
-  });
-
-  it('rejects with generic message when error has no message field', async () => {
-    const client = new GatewayClient('ws://localhost', 'token');
-    const ws = await doConnect(client);
-
-    const reqPromise = client.request('test', {});
-    const sent = JSON.parse(ws.send.mock.calls[0][0]);
-    ws.emit('message', JSON.stringify({ type: 'res', id: sent.id, ok: false }));
-
-    await expect(reqPromise).rejects.toThrow('Request failed');
-  });
-
-  it('ignores response for an unknown request id', async () => {
-    const client = new GatewayClient('ws://localhost', 'token');
-    const ws = await doConnect(client);
-
-    const reqPromise = client.request('test', {});
-    ws.emit('message', JSON.stringify({ type: 'res', id: 'stale-id', ok: true, payload: {} }));
-    await Promise.resolve();
-
-    let resolved = false;
-    reqPromise.then(() => { resolved = true; }).catch(() => {});
-    await Promise.resolve();
-    expect(resolved).toBe(false);
-
-    // Clean up to avoid open handles
-    client.disconnect();
-    await reqPromise.catch(() => {});
-  });
-
-  it('ignores messages with unknown type', async () => {
-    const client = new GatewayClient('ws://localhost', 'token');
-    const ws = await doConnect(client);
-
-    expect(() => {
-      ws.emit('message', JSON.stringify({ type: 'unknown_type', id: 'x' }));
-    }).not.toThrow();
-  });
-
-  it('ignores malformed JSON messages', async () => {
-    const client = new GatewayClient('ws://localhost', 'token');
-    const ws = await doConnect(client);
-
-    expect(() => {
-      ws.emit('message', '{ bad json');
-    }).not.toThrow();
-  });
-});
-
-describe('GatewayClient – connection close', () => {
-  it('marks as disconnected and rejects pending requests when connection closes', async () => {
-    const client = new GatewayClient('ws://localhost', 'token');
-    const ws = await doConnect(client);
-
-    const pendingReq = client.request('test', {});
-    ws.emit('close');
-
-    await expect(pendingReq).rejects.toThrow('Connection closed');
-    expect(client.isConnected()).toBe(false);
-  });
-});