agent-messenger 2.31.0 → 2.32.0

package/src/platforms/discord/listener.test.ts

@@ -1,6 +1,6 @@
 import { afterEach, describe, expect, mock, it } from 'bun:test'
 
-import { DiscordListener } from '@/platforms/discord/listener'
+import { DiscordListener, parseReadStates } from '@/platforms/discord/listener'
 import type {
   DiscordGatewayGenericEvent,
   DiscordGatewayMessageCreateEvent,
@@ -68,7 +68,7 @@ class MockWs {
     this.simulateMessage({ op: 10, d: { heartbeat_interval: interval } })
   }
 
-  simulateReady(sessionId = 'session_123') {
+  simulateReady(sessionId = 'session_123', readState?: unknown) {
     this.simulateMessage({
       op: 0,
       t: 'READY',
@@ -77,6 +77,7 @@ class MockWs {
         session_id: sessionId,
         resume_gateway_url: 'wss://resume.discord.gg',
         user: { id: 'U_SELF', username: 'testbot' },
+        ...(readState === undefined ? {} : { read_state: readState }),
       },
     })
   }
@@ -135,6 +136,33 @@ async function startConnecting(listener: DiscordListener): Promise<MockWs> {
   return ws
 }
 
+describe('parseReadStates', () => {
+  it('filters out non-channel read state types', () => {
+    const result = parseReadStates([
+      { id: 'c1', last_message_id: '100', mention_count: 1 },
+      { id: 'c2', read_state_type: 2, mention_count: 5 },
+    ])
+
+    expect(result).toEqual([{ channelId: 'c1', lastMessageId: '100', mentionCount: 1 }])
+  })
+
+  it('normalizes missing last_message_id and mention_count', () => {
+    const result = parseReadStates([{ id: 'c1' }])
+
+    expect(result).toEqual([{ channelId: 'c1', lastMessageId: null, mentionCount: 0 }])
+  })
+
+  it('skips malformed entries but keeps valid ones', () => {
+    const result = parseReadStates([{ id: 'c1', mention_count: 1 }, { mention_count: 3 }])
+
+    expect(result).toEqual([{ channelId: 'c1', lastMessageId: null, mentionCount: 1 }])
+  })
+
+  it('throws on a non-array, non-versioned payload', () => {
+    expect(() => parseReadStates({ foo: 'bar' })).toThrow(/invalid read_state/)
+  })
+})
+
 describe('DiscordListener', () => {
   let listener: DiscordListener
 
@@ -235,6 +263,45 @@ describe('DiscordListener', () => {
     })
   })
 
+  describe('read state', () => {
+    it('captures raw-array read_state from READY', async () => {
+      const client = createMockClient()
+      listener = new DiscordListener(client)
+
+      const started = listener.start()
+      const ws = await waitForSocket()
+      ws.simulateOpen()
+      ws.simulateHello()
+      ws.simulateReady('session_123', [{ id: 'c1', last_message_id: '100', mention_count: 2 }])
+      await started
+
+      expect(listener.getReadState()).toEqual([{ channelId: 'c1', lastMessageId: '100', mentionCount: 2 }])
+    })
+
+    it('captures versioned { entries } read_state from READY', async () => {
+      const client = createMockClient()
+      listener = new DiscordListener(client)
+
+      const started = listener.start()
+      const ws = await waitForSocket()
+      ws.simulateOpen()
+      ws.simulateHello()
+      ws.simulateReady('session_123', { version: 7, entries: [{ id: 'c1', last_message_id: '100', mention_count: 1 }] })
+      await started
+
+      expect(listener.getReadState()).toEqual([{ channelId: 'c1', lastMessageId: '100', mentionCount: 1 }])
+    })
+
+    it('defaults to an empty read state when READY omits read_state', async () => {
+      const client = createMockClient()
+      listener = new DiscordListener(client)
+
+      await startAndReady(listener)
+
+      expect(listener.getReadState()).toEqual([])
+    })
+  })
+
   describe('identify', () => {
     it('sends Identify after Hello', async () => {
       const client = createMockClient()

package/src/platforms/discord/listener.ts

@@ -3,8 +3,30 @@ import { EventEmitter } from 'events'
 import WebSocket from 'ws'
 
 import type { DiscordClient } from './client'
-import type { DiscordListenerEventMap, DiscordGatewayGenericEvent } from './types'
-import { DiscordGatewayOpcode } from './types'
+import type { DiscordListenerEventMap, DiscordGatewayGenericEvent, DiscordReadState } from './types'
+import { DiscordGatewayOpcode, DiscordRawReadStateSchema, DiscordReadyReadStateSchema } from './types'
+
+export function parseReadStates(value: unknown): DiscordReadState[] {
+  const parsed = DiscordReadyReadStateSchema.safeParse(value)
+  if (!parsed.success) {
+    throw new Error('Discord READY contained an invalid read_state payload')
+  }
+
+  const entries = Array.isArray(parsed.data) ? parsed.data : parsed.data.entries
+
+  const readStates: DiscordReadState[] = []
+  for (const entry of entries) {
+    const state = DiscordRawReadStateSchema.safeParse(entry)
+    if (!state.success) continue
+    if ((state.data.read_state_type ?? 0) !== 0) continue
+    readStates.push({
+      channelId: state.data.id,
+      lastMessageId: state.data.last_message_id ?? null,
+      mentionCount: state.data.mention_count ?? 0,
+    })
+  }
+  return readStates
+}
 
 const GATEWAY_URL = 'wss://gateway.discord.gg/?v=10&encoding=json'
 const GATEWAY_QUERY = '?v=10&encoding=json'
@@ -57,6 +79,7 @@ export class DiscordListener {
   private resumeGatewayUrl: string | null = null
   private token: string | null = null
   private cachedUser: { id: string; username: string } | null = null
+  private readState: DiscordReadState[] | null = null
   private generation = 0
   private startPromise: Promise<void> | null = null
   private pendingStartReject: ((error: Error) => void) | null = null
@@ -151,6 +174,7 @@ export class DiscordListener {
     this.resumeGatewayUrl = null
     this.token = null
     this.cachedUser = null
+    this.readState = null
     rejectStart?.(new Error('Discord gateway start was stopped before becoming ready'))
   }
 
@@ -174,6 +198,10 @@ export class DiscordListener {
     return this
   }
 
+  getReadState(): DiscordReadState[] | null {
+    return this.readState
+  }
+
   private isCurrent(generation: number, ws?: WebSocket): boolean {
     if (generation !== this.generation || !this.running) return false
     if (ws !== undefined && this.ws !== ws) return false
@@ -298,6 +326,7 @@ export class DiscordListener {
       this.sessionId = d.session_id
       this.resumeGatewayUrl = d.resume_gateway_url
       this.cachedUser = d.user
+      this.readState = d.read_state === undefined ? [] : parseReadStates(d.read_state)
       this.reconnectAttempts = 0
       this.emitter.emit('connected', { user: d.user, sessionId: d.session_id })
       return

package/src/platforms/discord/types.test.ts

@@ -150,6 +150,17 @@ it('DiscordReactionSchema validates reaction with custom emoji', () => {
   expect(result.success).toBe(true)
 })
 
+it('DiscordReactionSchema validates nullable emoji fields', () => {
+  const result = DiscordReactionSchema.safeParse({
+    emoji: {
+      id: null,
+      name: null,
+    },
+    count: 1,
+  })
+  expect(result.success).toBe(true)
+})
+
 it('DiscordReactionSchema rejects missing required fields', () => {
   const result = DiscordReactionSchema.safeParse({
     emoji: {

package/src/platforms/discord/types.ts

@@ -38,6 +38,7 @@ export interface DiscordMessage {
   timestamp: string
   edited_timestamp?: string
   thread_id?: string
+  reactions?: DiscordReaction[]
 }
 
 export interface DiscordUser {
@@ -58,8 +59,8 @@ export interface DiscordDMChannel {
 
 export interface DiscordReaction {
   emoji: {
-    id?: string
-    name: string
+    id?: string | null
+    name: string | null
   }
   count: number
 }
@@ -91,6 +92,26 @@ export interface DiscordUserNote {
   note: string
 }
 
+export interface DiscordReadState {
+  channelId: string
+  lastMessageId: string | null
+  mentionCount: number
+}
+
+export interface DiscordUnreadMention extends DiscordMention {
+  mention_count: number
+}
+
+export interface DiscordUnreadMentionsResult {
+  mentions: DiscordUnreadMention[]
+  count: number
+  // Account-wide unread-mention badge total; not narrowed by guildId because
+  // READY read states carry no guild association.
+  badgeCount: number
+  complete: boolean
+  windowDays: number
+}
+
 export interface DiscordSearchResult {
   id: string
   channel_id: string
@@ -190,6 +211,14 @@ export const DiscordChannelSchema = z.object({
   position: z.number().optional(),
 })
 
+export const DiscordReactionSchema = z.object({
+  emoji: z.object({
+    id: z.string().nullish(),
+    name: z.string().nullable(),
+  }),
+  count: z.number(),
+})
+
 export const DiscordMessageSchema = z.object({
   id: z.string(),
   channel_id: z.string(),
@@ -201,6 +230,7 @@ export const DiscordMessageSchema = z.object({
   timestamp: z.string(),
   edited_timestamp: z.string().optional(),
   thread_id: z.string().optional(),
+  reactions: z.array(DiscordReactionSchema).optional(),
 })
 
 export const DiscordUserSchema = z.object({
@@ -219,14 +249,6 @@ export const DiscordDMChannelSchema = z.object({
   name: z.string().optional(),
 })
 
-export const DiscordReactionSchema = z.object({
-  emoji: z.object({
-    id: z.string().optional(),
-    name: z.string(),
-  }),
-  count: z.number(),
-})
-
 export const DiscordFileSchema = z.object({
   id: z.string(),
   filename: z.string(),
@@ -402,6 +424,24 @@ export interface DiscordGatewayGenericEvent {
   [key: string]: unknown
 }
 
+// read_state_type 0 = channel read state (carries last_message_id); non-zero types
+// carry last_acked_id instead and must be filtered out for mention correlation.
+export const DiscordRawReadStateSchema = z.object({
+  id: z.string(),
+  read_state_type: z.number().optional(),
+  last_message_id: z.string().nullish(),
+  mention_count: z.number().optional(),
+})
+
+export type DiscordRawReadState = z.infer<typeof DiscordRawReadStateSchema>
+
+// READY sends read_state as a raw array, or as { entries, version } when the
+// VERSIONED_READ_STATES gateway capability is negotiated.
+export const DiscordReadyReadStateSchema = z.union([
+  z.array(z.unknown()),
+  z.object({ entries: z.array(z.unknown()), version: z.number().optional() }),
+])
+
 export type DiscordGatewayEvent =
   | DiscordGatewayMessageCreateEvent
   | DiscordGatewayMessageUpdateEvent