@workclaw/openclaw-workclaw 1.0.16 → 1.0.18

package/tests/message-context.test.ts

@@ -0,0 +1,313 @@
+/**
+ * Tests for message parsing: parseInboundMessage, parseWorkClawMessage, buildInboundContext.
+ */
+
+import { describe, expect, it } from 'vitest';
+import {
+  parseInboundMessage,
+  parseWorkClawMessage,
+  buildInboundContext,
+  OPENCLAW_WORKCLAW_CHANNEL,
+  type InboundMessage,
+} from '../src/gateway/message-context.js';
+
+// ---------------------------------------------------------------------------
+// parseInboundMessage
+// ---------------------------------------------------------------------------
+
+describe('parseInboundMessage', () => {
+  it('parses text from "text" field', () => {
+    const result = parseInboundMessage(JSON.stringify({ text: 'hello', from: 'user-1' }));
+    expect(result.text).toBe('hello');
+    expect(result.from).toBe('user-1');
+  });
+
+  it('falls back to "message" field when "text" is absent', () => {
+    const result = parseInboundMessage(JSON.stringify({ message: 'hi there' }));
+    expect(result.text).toBe('hi there');
+  });
+
+  it('falls back to "body" field when "text" and "message" are absent', () => {
+    const result = parseInboundMessage(JSON.stringify({ body: 'body text' }));
+    expect(result.text).toBe('body text');
+  });
+
+  it('falls back to raw data when no known field exists', () => {
+    const raw = 'plain text message';
+    const result = parseInboundMessage(raw);
+    expect(result.text).toBe(raw);
+  });
+
+  it('extracts chatId into "to"', () => {
+    const result = parseInboundMessage(JSON.stringify({ chatId: 'chat-abc' }));
+    expect(result.to).toBe('chat-abc');
+  });
+
+  it('sets chatType to "group" for group messages', () => {
+    const result = parseInboundMessage(JSON.stringify({ chatType: 'group' }));
+    expect(result.chatType).toBe('group');
+  });
+
+  it('sets chatType to "dm" for non-group messages', () => {
+    const result = parseInboundMessage(JSON.stringify({ chatType: 'dm' }));
+    expect(result.chatType).toBe('dm');
+  });
+
+  it('defaults chatType to "dm" when absent', () => {
+    const result = parseInboundMessage(JSON.stringify({}));
+    expect(result.chatType).toBe('dm');
+  });
+
+  it('handles non-JSON input gracefully', () => {
+    const result = parseInboundMessage('not json at all');
+    expect(result.text).toBe('not json at all');
+  });
+
+  it('stores raw JSON payload when allowRawJsonPayload=true', () => {
+    const input = { text: 'hi', extra: 'data' };
+    const result = parseInboundMessage(JSON.stringify(input), true);
+    expect(result.rawPayload).toBe(JSON.stringify(input));
+  });
+});
+
+// ---------------------------------------------------------------------------
+// parseWorkClawMessage
+// ---------------------------------------------------------------------------
+
+describe('parseWorkClawMessage', () => {
+  it('returns null for invalid JSON', () => {
+    const result = parseWorkClawMessage('not json');
+    expect(result).toBeNull();
+  });
+
+  it('parses SYSTEM/ping message', () => {
+    const msg = JSON.stringify({
+      type: 'SYSTEM',
+      metadata: { topic: 'ping' },
+    });
+    const result = parseWorkClawMessage(msg);
+    expect(result?.type).toBe('ping');
+  });
+
+  it('parses SYSTEM/disconnect message', () => {
+    const msg = JSON.stringify({
+      type: 'SYSTEM',
+      metadata: { topic: 'disconnect' },
+    });
+    const result = parseWorkClawMessage(msg);
+    expect(result?.type).toBe('disconnect');
+  });
+
+  it('ignores unknown SYSTEM topics', () => {
+    const msg = JSON.stringify({
+      type: 'SYSTEM',
+      metadata: { topic: 'unknown-topic' },
+    });
+    const result = parseWorkClawMessage(msg);
+    expect(result?.type).toBe('ignored');
+  });
+
+  it('parses EVENT/AGENT_CREATED', () => {
+    const msg = JSON.stringify({
+      type: 'EVENT',
+      metadata: { event: 'AGENT_CREATED' },
+      data: { agentId: '123' },
+    });
+    const result = parseWorkClawMessage(msg);
+    expect(result?.type).toBe('agent_created');
+    expect(result?.eventData).toEqual({ agentId: '123' });
+  });
+
+  it('parses EVENT/AGENT_UPDATED', () => {
+    const msg = JSON.stringify({
+      type: 'EVENT',
+      metadata: { event: 'AGENT_UPDATED' },
+      data: { agentId: '456' },
+    });
+    expect(parseWorkClawMessage(msg)?.type).toBe('agent_updated');
+  });
+
+  it('parses EVENT/AGENT_DELETED', () => {
+    const msg = JSON.stringify({
+      type: 'EVENT',
+      metadata: { event: 'AGENT_DELETED' },
+      data: { agentId: '789' },
+    });
+    expect(parseWorkClawMessage(msg)?.type).toBe('agent_deleted');
+  });
+
+  it('parses EVENT/TOOLS_LIST', () => {
+    const msg = JSON.stringify({
+      type: 'EVENT',
+      metadata: { event: 'TOOLS_LIST' },
+      data: { tools: [] },
+    });
+    expect(parseWorkClawMessage(msg)?.type).toBe('tools_list');
+  });
+
+  it('parses EVENT/SKILLS_LIST', () => {
+    const msg = JSON.stringify({
+      type: 'EVENT',
+      metadata: { event: 'SKILLS_LIST' },
+      data: {},
+    });
+    expect(parseWorkClawMessage(msg)?.type).toBe('skills_list');
+  });
+
+  it('parses EVENT/INIT_AGENT and unwraps JSON-string data', () => {
+    const innerData = { agentId: 12345 };
+    const msg = JSON.stringify({
+      type: 'EVENT',
+      metadata: { event: 'INIT_AGENT' },
+      data: JSON.stringify(innerData),
+    });
+    const result = parseWorkClawMessage(msg);
+    expect(result?.type).toBe('init_agent');
+    expect(result?.eventData).toEqual(innerData);
+  });
+
+  it('ignores unknown EVENT types', () => {
+    const msg = JSON.stringify({
+      type: 'EVENT',
+      metadata: { event: 'UNKNOWN_EVENT' },
+    });
+    expect(parseWorkClawMessage(msg)?.type).toBe('ignored');
+  });
+
+  it('parses CALLBACK/AGENT_MESSAGE with text in content field', () => {
+    const msg = JSON.stringify({
+      type: 'CALLBACK',
+      metadata: { topic: 'AGENT_MESSAGE' },
+      data: {
+        userId: 'user-abc',
+        conversationId: 'conv-123',
+        msgId: 'msg-456',
+        agentId: 42,
+        message: { content: 'hello from user' },
+      },
+    });
+    const result = parseWorkClawMessage(msg);
+    expect(result?.type).toBe('agent_message');
+    expect(result?.message?.text).toBe('hello from user');
+    expect(result?.message?.userId).toBe('user-abc');
+    expect(result?.message?.openConversationId).toBe('conv-123');
+    expect(result?.message?.messageId).toBe('msg-456');
+    expect(result?.message?.agentId).toBe(42);
+  });
+
+  it('parses CALLBACK/AGENT_MESSAGE with string message field', () => {
+    const msg = JSON.stringify({
+      type: 'CALLBACK',
+      metadata: { topic: 'AGENT_MESSAGE' },
+      data: {
+        userId: 'u1',
+        conversationId: 'c1',
+        msgId: 'm1',
+        message: 'plain text',
+      },
+    });
+    const result = parseWorkClawMessage(msg);
+    expect(result?.message?.text).toBe('plain text');
+  });
+
+  it('ignores non-AGENT_MESSAGE CALLBACK topics', () => {
+    const msg = JSON.stringify({
+      type: 'CALLBACK',
+      metadata: { topic: 'OTHER_TOPIC' },
+    });
+    expect(parseWorkClawMessage(msg)?.type).toBe('ignored');
+  });
+
+  it('unwraps JSON-string data field in CALLBACK', () => {
+    const innerData = {
+      userId: 'u2',
+      conversationId: 'c2',
+      msgId: 'm2',
+      message: { content: 'nested' },
+    };
+    const msg = JSON.stringify({
+      type: 'CALLBACK',
+      metadata: { topic: 'AGENT_MESSAGE' },
+      data: JSON.stringify(innerData),
+    });
+    const result = parseWorkClawMessage(msg);
+    expect(result?.message?.text).toBe('nested');
+  });
+
+  it('parses SKILL_DO_REMIND event', () => {
+    const msg = JSON.stringify({
+      type: 'EVENT',
+      metadata: { event: 'SKILL_DO_REMIND' },
+      data: { dotype: 'invoke', skillId: 's1' },
+    });
+    const result = parseWorkClawMessage(msg);
+    expect(result?.type).toBe('skills_event');
+    expect(result?.eventData?.topic).toBe('skills/invoke');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// buildInboundContext (without pluginRuntime)
+// ---------------------------------------------------------------------------
+
+describe('buildInboundContext – without pluginRuntime', () => {
+  const baseMessage: InboundMessage = {
+    text: 'test message',
+    to: 'agent-001',
+    from: 'user-xyz',
+    chatType: 'dm',
+    messageId: 'msg-001',
+    rawPayload: '{"text":"test message"}',
+    timestamp: 1700000000000,
+  };
+
+  it('returns correct basic context fields', async () => {
+    const ctx = await buildInboundContext(baseMessage, 'default', {});
+    expect(ctx.Body).toBe('test message');
+    expect(ctx.From).toBe('user-xyz');
+    expect(ctx.To).toBe('agent-001');
+    expect(ctx.ChatType).toBe('dm');
+    expect(ctx.AccountId).toBe('default');
+    expect(ctx.Provider).toBe(OPENCLAW_WORKCLAW_CHANNEL);
+    expect(ctx.MessageSid).toBe('msg-001');
+    expect(ctx.Timestamp).toBe(1700000000000);
+  });
+
+  it('sets SessionKey when agentId is provided', async () => {
+    const ctx = await buildInboundContext(baseMessage, 'default', {}, 'agent-99');
+    expect(ctx.SessionKey).toContain('agent-99');
+    expect(ctx.SessionKey).toContain('default');
+    expect(ctx.SessionKey).toContain('user-xyz');
+  });
+
+  it('does not set SessionKey when agentId is "main"', async () => {
+    const ctx = await buildInboundContext(baseMessage, 'default', {}, 'main');
+    expect(ctx.SessionKey).toBeUndefined();
+  });
+
+  it('uses sessionKey from rawPayload when present', async () => {
+    const msgWithSession: InboundMessage = {
+      ...baseMessage,
+      rawPayload: JSON.stringify({ sessionKey: 'custom-session-key-123' }),
+    };
+    const ctx = await buildInboundContext(msgWithSession, 'default', {}, 'agent-1');
+    expect(ctx.SessionKey).toBe('custom-session-key-123');
+  });
+
+  it('OriginatingChannel and OriginatingTo are set correctly', async () => {
+    const ctx = await buildInboundContext(baseMessage, 'default', {});
+    expect(ctx.OriginatingChannel).toBe(OPENCLAW_WORKCLAW_CHANNEL);
+    expect(ctx.OriginatingTo).toBe('agent-001');
+  });
+
+  it('BodyForAgent returns text content', async () => {
+    const ctx = await buildInboundContext(baseMessage, 'default', {});
+    expect(ctx.BodyForAgent).toBe('test message');
+  });
+
+  it('handles group chatType', async () => {
+    const groupMsg: InboundMessage = { ...baseMessage, chatType: 'group' };
+    const ctx = await buildInboundContext(groupMsg, 'default', {});
+    expect(ctx.ChatType).toBe('group');
+  });
+});

package/tests/reconnect.test.ts

@@ -0,0 +1,257 @@
+/**
+ * Tests for reconnect scheduler logic.
+ * Network/WebSocket calls are not made — we test scheduling, dedup, stop, and error handling logic.
+ */
+
+import { describe, expect, it, vi, beforeEach, afterEach } from 'vitest';
+import { createReconnectScheduler } from '../src/gateway/reconnect.js';
+
+// Mock the external dependencies so tests don't touch the network
+vi.mock('../src/connection/workclaw-client.js', () => ({
+  clearWorkclawTokenCache: vi.fn(),
+  openWorkclawConnection: vi.fn().mockRejectedValue(new Error('network error')),
+}));
+
+vi.mock('../src/runtime.js', () => ({
+  setWorkclawWsConnection: vi.fn(),
+  clearWorkclawWsConnection: vi.fn(),
+}));
+
+vi.mock('undici', () => ({
+  Agent: vi.fn(),
+  WebSocket: vi.fn(),
+}));
+
+const baseConfig = {
+  appKey: 'test-key',
+  appSecret: 'test-secret',
+  baseUrl: 'http://localhost:9999',
+};
+
+beforeEach(() => {
+  vi.useFakeTimers();
+});
+
+afterEach(() => {
+  vi.useRealTimers();
+  vi.clearAllMocks();
+});
+
+// ---------------------------------------------------------------------------
+// Basic scheduling
+// ---------------------------------------------------------------------------
+
+describe('createReconnectScheduler – scheduling', () => {
+  it('returns scheduleReconnect and stopReconnect functions', () => {
+    const scheduler = createReconnectScheduler({
+      key: 'test',
+      config: baseConfig,
+      onMessage: vi.fn(),
+    });
+    expect(typeof scheduler.scheduleReconnect).toBe('function');
+    expect(typeof scheduler.stopReconnect).toBe('function');
+  });
+
+  it('does not reconnect immediately — waits for timer', () => {
+    const logs: string[] = [];
+    const scheduler = createReconnectScheduler({
+      key: 'test',
+      config: baseConfig,
+      onMessage: vi.fn(),
+      log: { info: (m) => logs.push(m) },
+    });
+
+    scheduler.scheduleReconnect();
+
+    // Nothing should have run yet
+    expect(logs.some(l => l.includes('Attempting'))).toBe(false);
+    expect(logs.some(l => l.includes('Scheduling'))).toBe(true);
+  });
+
+  it('deduplicates concurrent scheduleReconnect calls', () => {
+    const logs: string[] = [];
+    const scheduler = createReconnectScheduler({
+      key: 'test',
+      config: baseConfig,
+      onMessage: vi.fn(),
+      log: { info: (m) => logs.push(m) },
+    });
+
+    scheduler.scheduleReconnect();
+    scheduler.scheduleReconnect();
+    scheduler.scheduleReconnect();
+
+    const scheduledLogs = logs.filter(l => l.includes('Scheduling'));
+    const skippedLogs = logs.filter(l => l.includes('Already scheduled'));
+    expect(scheduledLogs).toHaveLength(1);
+    expect(skippedLogs).toHaveLength(2);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// stopReconnect
+// ---------------------------------------------------------------------------
+
+describe('createReconnectScheduler – stopReconnect', () => {
+  it('prevents reconnect after stop is called', () => {
+    const logs: string[] = [];
+    const scheduler = createReconnectScheduler({
+      key: 'test',
+      config: baseConfig,
+      onMessage: vi.fn(),
+      log: { info: (m) => logs.push(m) },
+    });
+
+    scheduler.stopReconnect();
+    scheduler.scheduleReconnect();
+
+    const stoppedLog = logs.find(l => l.includes('Stopped'));
+    expect(stoppedLog).toBeTruthy();
+    expect(logs.some(l => l.includes('Scheduling'))).toBe(false);
+  });
+
+  it('cancels a pending timer when stop is called', () => {
+    const logs: string[] = [];
+    const scheduler = createReconnectScheduler({
+      key: 'test',
+      config: baseConfig,
+      onMessage: vi.fn(),
+      log: { info: (m) => logs.push(m) },
+    });
+
+    scheduler.scheduleReconnect();
+    expect(logs.some(l => l.includes('Scheduling'))).toBe(true);
+
+    scheduler.stopReconnect();
+
+    // Advance time past the reconnect delay — nothing should fire
+    vi.advanceTimersByTime(10000);
+
+    // scheduleReconnect after stop should be rejected
+    scheduler.scheduleReconnect();
+    expect(logs.filter(l => l.includes('Stopped'))).toHaveLength(1);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Error handling: auth error stops reconnect
+// ---------------------------------------------------------------------------
+
+describe('createReconnectScheduler – auth error handling', () => {
+  it('stops reconnecting after auth error', async () => {
+    const { openWorkclawConnection } = await import('../src/connection/workclaw-client.js');
+    vi.mocked(openWorkclawConnection).mockRejectedValueOnce(
+      new Error('{"errCode":2001,"message":"鉴权失败"}'),
+    );
+
+    const logs: string[] = [];
+    const errorLogs: string[] = [];
+    const scheduler = createReconnectScheduler({
+      key: 'auth-test',
+      config: baseConfig,
+      onMessage: vi.fn(),
+      log: {
+        info: (m) => logs.push(m),
+        error: (m) => errorLogs.push(m),
+        warn: vi.fn(),
+      },
+    });
+
+    scheduler.scheduleReconnect();
+    await vi.advanceTimersByTimeAsync(10000);
+
+    expect(errorLogs.some(l => l.includes('Authentication failed'))).toBe(true);
+
+    // Subsequent scheduleReconnect should be stopped
+    scheduler.scheduleReconnect();
+    expect(logs.some(l => l.includes('Stopped'))).toBe(true);
+  });
+
+  it('stops reconnecting on "invalid credentials" error', async () => {
+    const { openWorkclawConnection } = await import('../src/connection/workclaw-client.js');
+    vi.mocked(openWorkclawConnection).mockRejectedValueOnce(
+      new Error('invalid credentials'),
+    );
+
+    const errorLogs: string[] = [];
+    const scheduler = createReconnectScheduler({
+      key: 'cred-test',
+      config: baseConfig,
+      onMessage: vi.fn(),
+      log: { error: (m) => errorLogs.push(m), info: vi.fn(), warn: vi.fn() },
+    });
+
+    scheduler.scheduleReconnect();
+    await vi.advanceTimersByTimeAsync(10000);
+
+    expect(errorLogs.some(l => l.includes('Authentication failed'))).toBe(true);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Error handling: rate limit resets backoff
+// ---------------------------------------------------------------------------
+
+describe('createReconnectScheduler – rate limit handling', () => {
+  it('retries with minimal backoff on rate limit error', async () => {
+    const { openWorkclawConnection } = await import('../src/connection/workclaw-client.js');
+    vi.mocked(openWorkclawConnection).mockRejectedValue(
+      new Error('访问过于频繁，请稍后再试'),
+    );
+
+    const logs: string[] = [];
+    const warnLogs: string[] = [];
+    const scheduler = createReconnectScheduler({
+      key: 'rate-test',
+      config: baseConfig,
+      onMessage: vi.fn(),
+      log: {
+        info: (m) => logs.push(m),
+        warn: (m) => warnLogs.push(m),
+        error: vi.fn(),
+      },
+    });
+
+    // Stop after first reschedule so timer doesn't loop infinitely
+    const orig = scheduler.scheduleReconnect;
+    let rescheduleCount = 0;
+    scheduler.scheduleReconnect();
+
+    // Advance time to trigger first attempt
+    await vi.advanceTimersByTimeAsync(10000);
+
+    expect(warnLogs.some(l => l.includes('Rate limited'))).toBe(true);
+    // Should have scheduled again with low backoff
+    expect(logs.some(l => l.includes('Scheduling') && l.includes('base=1000'))).toBe(true);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Generic error: continues reconnecting
+// ---------------------------------------------------------------------------
+
+describe('createReconnectScheduler – generic error', () => {
+  it('schedules attempt after generic network error', async () => {
+    const { openWorkclawConnection } = await import('../src/connection/workclaw-client.js');
+    vi.mocked(openWorkclawConnection).mockRejectedValueOnce(
+      new Error('network error'),
+    );
+
+    const logs: string[] = [];
+    const scheduler = createReconnectScheduler({
+      key: 'net-test',
+      config: baseConfig,
+      onMessage: vi.fn(),
+      log: { info: (m) => logs.push(m), error: vi.fn(), warn: vi.fn() },
+    });
+
+    scheduler.scheduleReconnect();
+
+    // Advance enough to trigger the attempt
+    await vi.advanceTimersByTimeAsync(10000);
+
+    // Should have scheduled initial reconnect
+    const schedulingLogs = logs.filter(l => l.includes('Scheduling'));
+    expect(schedulingLogs.length).toBe(1);
+  });
+});

package/tests/workclaw-client.test.ts

@@ -0,0 +1,112 @@
+/**
+ * Tests for workclaw-client: token cache, normalizeBaseUrl, createWsEndpoint logic.
+ * Network calls (doFetchJson) are not tested here — those require a real server.
+ */
+
+import { describe, expect, it, beforeEach } from 'vitest';
+import {
+  normalizeBaseUrl,
+  clearWorkclawTokenCache,
+  getWorkclawAccessToken,
+} from '../src/connection/workclaw-client.js';
+
+// ---------------------------------------------------------------------------
+// normalizeBaseUrl
+// ---------------------------------------------------------------------------
+
+describe('normalizeBaseUrl', () => {
+  it('returns default URL when value is undefined', () => {
+    expect(normalizeBaseUrl(undefined)).toBe('https://open.workbrain.cn/open-apis');
+  });
+
+  it('returns default URL when value is empty string', () => {
+    expect(normalizeBaseUrl('')).toBe('https://open.workbrain.cn/open-apis');
+  });
+
+  it('strips trailing slash', () => {
+    expect(normalizeBaseUrl('http://localhost:8080/')).toBe('http://localhost:8080');
+  });
+
+  it('leaves URL without trailing slash unchanged', () => {
+    expect(normalizeBaseUrl('http://localhost:8080')).toBe('http://localhost:8080');
+  });
+
+  it('trims whitespace before processing', () => {
+    // trim + strip trailing slash — both happen, result has no trailing slash
+    expect(normalizeBaseUrl('  http://example.com/  ')).toBe('http://example.com');
+    expect(normalizeBaseUrl('  http://example.com/  '.trim())).toBe('http://example.com');
+  });
+
+  it('handles multiple trailing slashes — strips only last one', () => {
+    // The implementation strips one trailing slash
+    expect(normalizeBaseUrl('http://example.com//')).toBe('http://example.com/');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// clearWorkclawTokenCache
+// ---------------------------------------------------------------------------
+
+describe('clearWorkclawTokenCache', () => {
+  it('does not throw when clearing a key that was never set', () => {
+    expect(() => clearWorkclawTokenCache('non-existent-key')).not.toThrow();
+  });
+
+  it('can be called multiple times for the same key without error', () => {
+    clearWorkclawTokenCache('key-abc');
+    clearWorkclawTokenCache('key-abc');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// getWorkclawAccessToken — error handling
+// ---------------------------------------------------------------------------
+
+describe('getWorkclawAccessToken – validation', () => {
+  beforeEach(() => {
+    clearWorkclawTokenCache('test-cache-key');
+  });
+
+  it('throws when appKey is missing', async () => {
+    await expect(
+      getWorkclawAccessToken('test-cache-key', {
+        baseUrl: 'http://localhost:9999',
+        appKey: '',
+        appSecret: 'secret',
+      }),
+    ).rejects.toThrow('Missing appKey/appSecret');
+  });
+
+  it('throws when appSecret is missing', async () => {
+    await expect(
+      getWorkclawAccessToken('test-cache-key', {
+        baseUrl: 'http://localhost:9999',
+        appKey: 'key',
+        appSecret: '',
+      }),
+    ).rejects.toThrow('Missing appKey/appSecret');
+  });
+
+  it('throws when both appKey and appSecret are missing', async () => {
+    await expect(
+      getWorkclawAccessToken('test-cache-key', {
+        baseUrl: 'http://localhost:9999',
+      }),
+    ).rejects.toThrow('Missing appKey/appSecret');
+  });
+
+  it('uses cached token on second call without hitting network', async () => {
+    // Manually prime the cache by calling with valid config — but since we
+    // have no server, we just verify that clearing and re-requesting fails fast.
+    // This test documents the cache behavior by ensuring clear() invalidates it.
+    clearWorkclawTokenCache('primed-key');
+    await expect(
+      getWorkclawAccessToken('primed-key', {
+        baseUrl: 'http://127.0.0.1:1', // unreachable
+        appKey: 'key',
+        appSecret: 'secret',
+        requestTimeout: 500,
+      }),
+    ).rejects.toThrow(); // network error or timeout, not validation error
+  });
+});

package/tsconfig.json

@@ -1,11 +1,14 @@
 {
-  "extends": "../../tsconfig.json",
   "compilerOptions": {
-    "rootDir": "./src",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "target": "ES2023",
+    "rootDir": ".",
+    "outDir": "dist",
     "declaration": true,
-    "declarationMap": true,
-    "outDir": "./dist"
+    "skipLibCheck": true
   },
-  "include": ["src/**/*"],
+  "include": ["./**/*.ts", "./index.ts"],
   "exclude": ["node_modules", "dist"]
 }
+