agent-messenger 1.14.0 → 2.0.0

package/src/platforms/discord/listener.ts

@@ -0,0 +1,297 @@
+import { EventEmitter } from 'events'
+
+import WebSocket from 'ws'
+
+import type { DiscordClient } from './client'
+import type { DiscordListenerEventMap, DiscordGatewayGenericEvent } from './types'
+import { DiscordGatewayOpcode, DiscordIntent } from './types'
+
+const GATEWAY_URL = 'wss://gateway.discord.gg/?v=10&encoding=json'
+const RECONNECT_BASE_DELAY = 1_000
+const RECONNECT_MAX_DELAY = 30_000
+const NON_RECOVERABLE_CLOSE_CODES = [4004, 4010, 4011, 4012, 4013, 4014]
+const SESSION_RESET_CLOSE_CODES = [4007, 4009]
+
+const DEFAULT_INTENTS =
+  DiscordIntent.Guilds |
+  DiscordIntent.GuildMessages |
+  DiscordIntent.GuildMessageReactions |
+  DiscordIntent.GuildMessageTyping |
+  DiscordIntent.DirectMessages |
+  DiscordIntent.DirectMessageReactions |
+  DiscordIntent.DirectMessageTyping
+
+type EventKey = keyof DiscordListenerEventMap
+
+export class DiscordListener {
+  private client: DiscordClient
+  private intents: number
+  private running = false
+  private ws: WebSocket | null = null
+  private emitter = new EventEmitter()
+  private heartbeatTimer: ReturnType<typeof setInterval> | null = null
+  private heartbeatAckReceived = true
+  private heartbeatJitterTimer: ReturnType<typeof setTimeout> | null = null
+  private invalidSessionTimer: ReturnType<typeof setTimeout> | null = null
+  private reconnectTimer: ReturnType<typeof setTimeout> | null = null
+  private reconnectAttempts = 0
+  private sequence: number | null = null
+  private sessionId: string | null = null
+  private resumeGatewayUrl: string | null = null
+  private token: string | null = null
+  private cachedUser: { id: string; username: string } | null = null
+
+  constructor(client: DiscordClient, options?: { intents?: number }) {
+    this.client = client
+    this.intents = options?.intents ?? DEFAULT_INTENTS
+  }
+
+  async start(): Promise<void> {
+    if (this.running) return
+    this.running = true
+    this.reconnectAttempts = 0
+    await this.connect()
+  }
+
+  stop(): void {
+    this.running = false
+    this.clearTimers()
+    if (this.ws) {
+      this.ws.close()
+      this.ws = null
+    }
+    this.sequence = null
+    this.sessionId = null
+    this.resumeGatewayUrl = null
+    this.token = null
+    this.cachedUser = null
+  }
+
+  on<K extends EventKey>(event: K, listener: (...args: DiscordListenerEventMap[K]) => void): this {
+    this.emitter.on(event, listener as (...args: any[]) => void)
+    return this
+  }
+
+  off<K extends EventKey>(event: K, listener: (...args: DiscordListenerEventMap[K]) => void): this {
+    this.emitter.off(event, listener as (...args: any[]) => void)
+    return this
+  }
+
+  once<K extends EventKey>(event: K, listener: (...args: DiscordListenerEventMap[K]) => void): this {
+    this.emitter.once(event, listener as (...args: any[]) => void)
+    return this
+  }
+
+  private async connect(): Promise<void> {
+    if (!this.running) return
+
+    try {
+      const { token } = await this.client.gatewayConnect()
+      if (!this.running) return
+
+      this.token = token
+
+      const url = this.resumeGatewayUrl ?? GATEWAY_URL
+      const ws = new WebSocket(url)
+      this.ws = ws
+
+      ws.on('open', () => {
+        if (!this.running) {
+          ws.close()
+          return
+        }
+        this.reconnectAttempts = 0
+      })
+
+      ws.on('message', (raw) => {
+        try {
+          const data = JSON.parse(raw.toString())
+          this.handleMessage(data)
+        } catch {
+          // malformed message, ignore
+        }
+      })
+
+      ws.on('close', (code) => {
+        this.clearTimers()
+        if (this.ws === ws) this.ws = null
+        if (NON_RECOVERABLE_CLOSE_CODES.includes(code)) {
+          this.emitter.emit('error', new Error(`Discord gateway closed with non-recoverable code ${code}`))
+          this.running = false
+          return
+        }
+        if (SESSION_RESET_CLOSE_CODES.includes(code)) {
+          this.sequence = null
+          this.sessionId = null
+          this.resumeGatewayUrl = null
+        }
+        if (this.running) {
+          this.emitter.emit('disconnected')
+          this.scheduleReconnect()
+        }
+      })
+
+      ws.on('error', (err) => {
+        this.emitter.emit('error', err instanceof Error ? err : new Error(String(err)))
+      })
+    } catch (error) {
+      this.emitter.emit('error', error instanceof Error ? error : new Error(String(error)))
+      if (this.running) {
+        this.scheduleReconnect()
+      }
+    }
+  }
+
+  private handleMessage(data: { op: number; d: any; s?: number; t?: string }): void {
+    const { op, d, s, t } = data
+
+    switch (op) {
+      case DiscordGatewayOpcode.Hello:
+        this.startHeartbeat(d.heartbeat_interval)
+        if (this.sessionId) {
+          this.sendResume()
+        } else {
+          this.sendIdentify()
+        }
+        break
+
+      case DiscordGatewayOpcode.HeartbeatACK:
+        this.heartbeatAckReceived = true
+        break
+
+      case DiscordGatewayOpcode.Dispatch:
+        if (typeof s === 'number') this.sequence = s
+        if (t) this.handleDispatch(t, d)
+        break
+
+      case DiscordGatewayOpcode.Reconnect:
+        this.reconnectAttempts = 0
+        this.ws?.close()
+        break
+
+      case DiscordGatewayOpcode.InvalidSession: {
+        const currentWs = this.ws
+        if (d === true) {
+          const delay = 1000 + Math.random() * 4000
+          this.invalidSessionTimer = setTimeout(() => {
+            this.invalidSessionTimer = null
+            if (currentWs && currentWs === this.ws) currentWs.close()
+          }, delay)
+        } else {
+          this.sequence = null
+          this.sessionId = null
+          this.resumeGatewayUrl = null
+          currentWs?.close()
+        }
+        break
+      }
+
+      case DiscordGatewayOpcode.Heartbeat:
+        this.sendHeartbeat()
+        break
+    }
+  }
+
+  private handleDispatch(t: string, d: any): void {
+    if (t === 'READY') {
+      this.sessionId = d.session_id
+      this.resumeGatewayUrl = d.resume_gateway_url
+      this.cachedUser = d.user
+      this.emitter.emit('connected', { user: d.user, sessionId: d.session_id })
+      return
+    }
+
+    if (t === 'RESUMED') {
+      this.emitter.emit('connected', { user: this.cachedUser!, sessionId: this.sessionId! })
+      return
+    }
+
+    const eventType = t.toLowerCase()
+    const event: DiscordGatewayGenericEvent = { ...d, type: t }
+    this.emitter.emit(eventType, event)
+    this.emitter.emit('discord_event', event)
+  }
+
+  private sendIdentify(): void {
+    this.ws?.send(
+      JSON.stringify({
+        op: DiscordGatewayOpcode.Identify,
+        d: {
+          token: this.token,
+          intents: this.intents,
+          properties: {
+            os: 'linux',
+            browser: 'agent-messenger',
+            device: 'agent-messenger',
+          },
+        },
+      }),
+    )
+  }
+
+  private sendResume(): void {
+    this.ws?.send(
+      JSON.stringify({
+        op: DiscordGatewayOpcode.Resume,
+        d: {
+          token: this.token,
+          session_id: this.sessionId,
+          seq: this.sequence,
+        },
+      }),
+    )
+  }
+
+  private sendHeartbeat(): void {
+    this.ws?.send(JSON.stringify({ op: DiscordGatewayOpcode.Heartbeat, d: this.sequence }))
+  }
+
+  private startHeartbeat(interval: number): void {
+    this.clearHeartbeatTimers()
+    this.heartbeatAckReceived = true
+
+    this.heartbeatJitterTimer = setTimeout(() => {
+      this.heartbeatJitterTimer = null
+      this.heartbeatAckReceived = false
+      this.sendHeartbeat()
+
+      this.heartbeatTimer = setInterval(() => {
+        if (!this.heartbeatAckReceived) {
+          this.ws?.close()
+          return
+        }
+        this.heartbeatAckReceived = false
+        this.sendHeartbeat()
+      }, interval)
+    }, Math.random() * interval)
+  }
+
+  private scheduleReconnect(): void {
+    const delay = Math.min(RECONNECT_BASE_DELAY * 2 ** this.reconnectAttempts, RECONNECT_MAX_DELAY)
+    this.reconnectAttempts++
+    this.reconnectTimer = setTimeout(() => this.connect(), delay)
+  }
+
+  private clearHeartbeatTimers(): void {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer)
+      this.heartbeatTimer = null
+    }
+    if (this.heartbeatJitterTimer) {
+      clearTimeout(this.heartbeatJitterTimer)
+      this.heartbeatJitterTimer = null
+    }
+  }
+
+  private clearTimers(): void {
+    this.clearHeartbeatTimers()
+    if (this.invalidSessionTimer) {
+      clearTimeout(this.invalidSessionTimer)
+      this.invalidSessionTimer = null
+    }
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer)
+      this.reconnectTimer = null
+    }
+  }
+}

package/src/platforms/discord/types.ts

@@ -283,6 +283,139 @@ export const DiscordConfigSchema = z.object({
   ),
 })
 
+// Gateway opcodes
+export const DiscordGatewayOpcode = {
+  Dispatch: 0,
+  Heartbeat: 1,
+  Identify: 2,
+  PresenceUpdate: 3,
+  VoiceStateUpdate: 4,
+  Resume: 6,
+  Reconnect: 7,
+  RequestGuildMembers: 8,
+  InvalidSession: 9,
+  Hello: 10,
+  HeartbeatACK: 11,
+} as const
+
+// Gateway intents (bitfield values)
+export const DiscordIntent = {
+  Guilds: 1 << 0,
+  GuildMembers: 1 << 1, // privileged
+  GuildModeration: 1 << 2,
+  GuildPresences: 1 << 8, // privileged
+  GuildMessages: 1 << 9,
+  GuildMessageReactions: 1 << 10,
+  GuildMessageTyping: 1 << 11,
+  DirectMessages: 1 << 12,
+  DirectMessageReactions: 1 << 13,
+  DirectMessageTyping: 1 << 14,
+  MessageContent: 1 << 15, // privileged
+} as const
+
+// Gateway dispatch event payloads
+export interface DiscordGatewayMessageCreateEvent {
+  type: 'MESSAGE_CREATE'
+  id: string
+  channel_id: string
+  guild_id?: string
+  author: { id: string; username: string }
+  content: string
+  timestamp: string
+  edited_timestamp?: string
+  mentions?: DiscordUser[]
+  attachments?: DiscordFile[]
+}
+
+export interface DiscordGatewayMessageUpdateEvent {
+  type: 'MESSAGE_UPDATE'
+  id: string
+  channel_id: string
+  guild_id?: string
+  content?: string
+  edited_timestamp?: string
+}
+
+export interface DiscordGatewayMessageDeleteEvent {
+  type: 'MESSAGE_DELETE'
+  id: string
+  channel_id: string
+  guild_id?: string
+}
+
+export interface DiscordGatewayReactionEvent {
+  type: 'MESSAGE_REACTION_ADD' | 'MESSAGE_REACTION_REMOVE'
+  user_id: string
+  channel_id: string
+  message_id: string
+  guild_id?: string
+  emoji: { id?: string; name: string }
+}
+
+export interface DiscordGatewayMemberEvent {
+  type: 'GUILD_MEMBER_ADD' | 'GUILD_MEMBER_REMOVE'
+  guild_id: string
+  user: { id: string; username: string }
+}
+
+export interface DiscordGatewayPresenceEvent {
+  type: 'PRESENCE_UPDATE'
+  user: { id: string }
+  guild_id: string
+  status: 'online' | 'idle' | 'dnd' | 'offline'
+  activities?: Array<{ name: string; type: number }>
+}
+
+export interface DiscordGatewayTypingEvent {
+  type: 'TYPING_START'
+  user_id: string
+  channel_id: string
+  guild_id?: string
+  timestamp: number
+}
+
+export interface DiscordGatewayChannelEvent {
+  type: 'CHANNEL_CREATE' | 'CHANNEL_UPDATE' | 'CHANNEL_DELETE'
+  id: string
+  guild_id?: string
+  name?: string
+}
+
+export interface DiscordGatewayGenericEvent {
+  type: string
+  [key: string]: unknown
+}
+
+export type DiscordGatewayEvent =
+  | DiscordGatewayMessageCreateEvent
+  | DiscordGatewayMessageUpdateEvent
+  | DiscordGatewayMessageDeleteEvent
+  | DiscordGatewayReactionEvent
+  | DiscordGatewayMemberEvent
+  | DiscordGatewayPresenceEvent
+  | DiscordGatewayTypingEvent
+  | DiscordGatewayChannelEvent
+  | DiscordGatewayGenericEvent
+
+export interface DiscordListenerEventMap {
+  message_create: [event: DiscordGatewayMessageCreateEvent]
+  message_update: [event: DiscordGatewayMessageUpdateEvent]
+  message_delete: [event: DiscordGatewayMessageDeleteEvent]
+  message_reaction_add: [event: DiscordGatewayReactionEvent]
+  message_reaction_remove: [event: DiscordGatewayReactionEvent]
+  guild_member_add: [event: DiscordGatewayMemberEvent]
+  guild_member_remove: [event: DiscordGatewayMemberEvent]
+  presence_update: [event: DiscordGatewayPresenceEvent]
+  typing_start: [event: DiscordGatewayTypingEvent]
+  channel_create: [event: DiscordGatewayChannelEvent]
+  channel_update: [event: DiscordGatewayChannelEvent]
+  channel_delete: [event: DiscordGatewayChannelEvent]
+  discord_event: [event: DiscordGatewayGenericEvent]
+  connected: [info: { user: { id: string; username: string }; sessionId: string }]
+  disconnected: []
+  error: [error: Error]
+}
+
 export class DiscordError extends Error {
   code: string
 

package/src/platforms/discordbot/client.test.ts

@@ -48,13 +48,13 @@ describe('DiscordBotClient', () => {
   }
 
   describe('constructor', () => {
-    test('requires token', () => {
-      expect(() => new DiscordBotClient('')).toThrow(DiscordBotError)
-      expect(() => new DiscordBotClient('')).toThrow('Token is required')
+    test('requires token', async () => {
+      await expect(new DiscordBotClient().login({ token: '' })).rejects.toThrow(DiscordBotError)
+      await expect(new DiscordBotClient().login({ token: '' })).rejects.toThrow('Token is required')
     })
 
-    test('accepts valid token', () => {
-      const client = new DiscordBotClient('bot-test-token')
+    test('accepts valid token', async () => {
+      const client = await new DiscordBotClient().login({ token: 'bot-test-token' })
       expect(client).toBeInstanceOf(DiscordBotClient)
     })
   })
@@ -68,7 +68,7 @@ describe('DiscordBotClient', () => {
         avatar: 'abc123',
       })
 
-      const client = new DiscordBotClient('my-bot-token')
+      const client = await new DiscordBotClient().login({ token: 'my-bot-token' })
       const user = await client.testAuth()
 
       expect(user.id).toBe('123456789')
@@ -84,7 +84,7 @@ describe('DiscordBotClient', () => {
     test('throws DiscordBotError on API error', async () => {
       mockResponse({ message: 'Unauthorized', code: 401 }, 401)
 
-      const client = new DiscordBotClient('bad-token')
+      const client = await new DiscordBotClient().login({ token: 'bad-token' })
       await expect(client.testAuth()).rejects.toThrow(DiscordBotError)
     })
   })
@@ -96,7 +96,7 @@ describe('DiscordBotClient', () => {
         { id: '222', name: 'Guild Two' },
       ])
 
-      const client = new DiscordBotClient('bot-token')
+      const client = await new DiscordBotClient().login({ token: 'bot-token' })
       const guilds = await client.listGuilds()
 
       expect(guilds).toHaveLength(2)
@@ -109,7 +109,7 @@ describe('DiscordBotClient', () => {
     test('returns guild info', async () => {
       mockResponse({ id: '111', name: 'Test Guild' })
 
-      const client = new DiscordBotClient('bot-token')
+      const client = await new DiscordBotClient().login({ token: 'bot-token' })
       const guild = await client.getGuild('111')
 
       expect(guild.id).toBe('111')
@@ -125,7 +125,7 @@ describe('DiscordBotClient', () => {
         { id: 'ch2', guild_id: '111', name: 'random', type: 0 },
       ])
 
-      const client = new DiscordBotClient('bot-token')
+      const client = await new DiscordBotClient().login({ token: 'bot-token' })
       const channels = await client.listChannels('111')
 
       expect(channels).toHaveLength(2)
@@ -144,7 +144,7 @@ describe('DiscordBotClient', () => {
         timestamp: '2024-01-01T00:00:00.000Z',
       })
 
-      const client = new DiscordBotClient('bot-token')
+      const client = await new DiscordBotClient().login({ token: 'bot-token' })
       const message = await client.sendMessage('ch1', 'Hello world')
 
       expect(message.content).toBe('Hello world')
@@ -162,7 +162,7 @@ describe('DiscordBotClient', () => {
         timestamp: '2024-01-01T00:00:00.000Z',
       })
 
-      const client = new DiscordBotClient('bot-token')
+      const client = await new DiscordBotClient().login({ token: 'bot-token' })
       await client.sendMessage('ch1', 'Thread reply', { thread_id: 'thread123' })
 
       expect(fetchCalls[0].options?.body).toBe(JSON.stringify({ content: 'Thread reply', thread_id: 'thread123' }))
@@ -180,7 +180,7 @@ describe('DiscordBotClient', () => {
         edited_timestamp: '2024-01-01T00:01:00.000Z',
       })
 
-      const client = new DiscordBotClient('bot-token')
+      const client = await new DiscordBotClient().login({ token: 'bot-token' })
       const message = await client.editMessage('ch1', 'msg1', 'Updated content')
 
       expect(message.content).toBe('Updated content')
@@ -194,7 +194,7 @@ describe('DiscordBotClient', () => {
     test('deletes message and returns void', async () => {
       mockResponse(null, 204)
 
-      const client = new DiscordBotClient('bot-token')
+      const client = await new DiscordBotClient().login({ token: 'bot-token' })
       const result = await client.deleteMessage('ch1', 'msg1')
 
       expect(result).toBeUndefined()
@@ -207,7 +207,7 @@ describe('DiscordBotClient', () => {
     test('adds reaction with encoded emoji', async () => {
       mockResponse(null, 204)
 
-      const client = new DiscordBotClient('bot-token')
+      const client = await new DiscordBotClient().login({ token: 'bot-token' })
       await client.addReaction('ch1', 'msg1', '👍')
 
       expect(fetchCalls[0].url).toBe(
@@ -221,7 +221,7 @@ describe('DiscordBotClient', () => {
     test('removes reaction with DELETE', async () => {
       mockResponse(null, 204)
 
-      const client = new DiscordBotClient('bot-token')
+      const client = await new DiscordBotClient().login({ token: 'bot-token' })
       await client.removeReaction('ch1', 'msg1', '👍')
 
       expect(fetchCalls[0].url).toBe(
@@ -235,7 +235,7 @@ describe('DiscordBotClient', () => {
     test('maps guild members to users', async () => {
       mockResponse([{ user: { id: 'u1', username: 'user1' } }, { user: { id: 'u2', username: 'user2' } }])
 
-      const client = new DiscordBotClient('bot-token')
+      const client = await new DiscordBotClient().login({ token: 'bot-token' })
       const users = await client.listUsers('111')
 
       expect(users).toHaveLength(2)
@@ -248,7 +248,7 @@ describe('DiscordBotClient', () => {
     test('returns user info', async () => {
       mockResponse({ id: 'u1', username: 'testuser' })
 
-      const client = new DiscordBotClient('bot-token')
+      const client = await new DiscordBotClient().login({ token: 'bot-token' })
       const user = await client.getUser('u1')
 
       expect(user.id).toBe('u1')
@@ -280,7 +280,7 @@ describe('DiscordBotClient', () => {
         ],
       })
 
-      const client = new DiscordBotClient('bot-token')
+      const client = await new DiscordBotClient().login({ token: 'bot-token' })
       const file = await client.uploadFile('ch1', tempFile)
 
       expect(file.filename).toBe('test-discordbot-upload.txt')
@@ -313,7 +313,7 @@ describe('DiscordBotClient', () => {
         },
       ])
 
-      const client = new DiscordBotClient('bot-token')
+      const client = await new DiscordBotClient().login({ token: 'bot-token' })
       const files = await client.listFiles('ch1')
 
       expect(files).toHaveLength(1)
@@ -330,7 +330,7 @@ describe('DiscordBotClient', () => {
         type: 11,
       })
 
-      const client = new DiscordBotClient('bot-token')
+      const client = await new DiscordBotClient().login({ token: 'bot-token' })
       const thread = await client.createThread('ch1', 'My Thread', { auto_archive_duration: 1440 })
 
       expect(thread.id).toBe('thread1')
@@ -351,7 +351,7 @@ describe('DiscordBotClient', () => {
         thread_metadata: { archived: true },
       })
 
-      const client = new DiscordBotClient('bot-token')
+      const client = await new DiscordBotClient().login({ token: 'bot-token' })
       await client.archiveThread('thread1')
 
       expect(fetchCalls[0].url).toBe('https://discord.com/api/v10/channels/thread1')
@@ -362,7 +362,7 @@ describe('DiscordBotClient', () => {
 
   describe('resolveChannel', () => {
     test('returns channel ID directly if all digits', async () => {
-      const client = new DiscordBotClient('bot-token')
+      const client = await new DiscordBotClient().login({ token: 'bot-token' })
       const id = await client.resolveChannel('111', '123456789')
 
       expect(id).toBe('123456789')
@@ -375,7 +375,7 @@ describe('DiscordBotClient', () => {
         { id: 'ch2', guild_id: '111', name: 'random', type: 0 },
       ])
 
-      const client = new DiscordBotClient('bot-token')
+      const client = await new DiscordBotClient().login({ token: 'bot-token' })
       const id = await client.resolveChannel('111', 'random')
 
       expect(id).toBe('ch2')
@@ -384,7 +384,7 @@ describe('DiscordBotClient', () => {
     test('strips # prefix when looking up by name', async () => {
       mockResponse([{ id: 'ch1', guild_id: '111', name: 'general', type: 0 }])
 
-      const client = new DiscordBotClient('bot-token')
+      const client = await new DiscordBotClient().login({ token: 'bot-token' })
       const id = await client.resolveChannel('111', '#general')
 
       expect(id).toBe('ch1')
@@ -393,7 +393,7 @@ describe('DiscordBotClient', () => {
     test('throws when channel name not found', async () => {
       mockResponse([{ id: 'ch1', guild_id: '111', name: 'general', type: 0 }])
 
-      const client = new DiscordBotClient('bot-token')
+      const client = await new DiscordBotClient().login({ token: 'bot-token' })
       try {
         await client.resolveChannel('111', 'nonexistent')
         expect.unreachable('Should have thrown')
@@ -418,7 +418,7 @@ describe('DiscordBotClient', () => {
         'X-RateLimit-Bucket': 'user-bucket',
       })
 
-      const client = new DiscordBotClient('bot-token')
+      const client = await new DiscordBotClient().login({ token: 'bot-token' })
       await client.testAuth()
 
       const startTime = Date.now()
@@ -433,7 +433,7 @@ describe('DiscordBotClient', () => {
       mockResponse({ message: 'Rate limited', retry_after: 0.1 }, 429, { 'Retry-After': '0.1' })
       mockResponse({ id: '123', username: 'bot' })
 
-      const client = new DiscordBotClient('bot-token')
+      const client = await new DiscordBotClient().login({ token: 'bot-token' })
       const user = await client.testAuth()
 
       expect(user.id).toBe('123')
@@ -447,7 +447,7 @@ describe('DiscordBotClient', () => {
       })
       mockResponse({ id: '123', username: 'bot' })
 
-      const client = new DiscordBotClient('bot-token')
+      const client = await new DiscordBotClient().login({ token: 'bot-token' })
       const user = await client.testAuth()
 
       expect(user.id).toBe('123')
@@ -459,7 +459,7 @@ describe('DiscordBotClient', () => {
         mockResponse({ message: 'Rate limited' }, 429, { 'Retry-After': '0.01' })
       }
 
-      const client = new DiscordBotClient('bot-token')
+      const client = await new DiscordBotClient().login({ token: 'bot-token' })
       await expect(client.testAuth()).rejects.toThrow(DiscordBotError)
       expect(fetchCalls.length).toBeLessThanOrEqual(4)
     })
@@ -470,7 +470,7 @@ describe('DiscordBotClient', () => {
       mockResponse({ message: 'Internal Server Error' }, 500)
       mockResponse({ id: '123', username: 'bot' })
 
-      const client = new DiscordBotClient('bot-token')
+      const client = await new DiscordBotClient().login({ token: 'bot-token' })
       const user = await client.testAuth()
 
       expect(user.id).toBe('123')
@@ -480,7 +480,7 @@ describe('DiscordBotClient', () => {
     test('does not retry on 4xx client errors (except 429)', async () => {
       mockResponse({ message: 'Not Found' }, 404)
 
-      const client = new DiscordBotClient('bot-token')
+      const client = await new DiscordBotClient().login({ token: 'bot-token' })
       await expect(client.testAuth()).rejects.toThrow(DiscordBotError)
       expect(fetchCalls.length).toBe(1)
     })
@@ -490,7 +490,7 @@ describe('DiscordBotClient', () => {
       mockResponse({ message: 'Error' }, 500)
       mockResponse({ id: '123', username: 'bot' })
 
-      const client = new DiscordBotClient('bot-token')
+      const client = await new DiscordBotClient().login({ token: 'bot-token' })
       const startTime = Date.now()
       await client.testAuth()
       const elapsed = Date.now() - startTime