agent-messenger 2.12.2 → 2.13.0

package/src/platforms/kakaotalk/client.ts

@@ -10,7 +10,7 @@ import { warn } from '@/shared/utils/stderr'
 import { LANG, PC_OS_NAME, getLocoDeviceConfig } from './protocol/config'
 import { LocoSession } from './protocol/session'
 import type { ChatListResponse, LocoPacket, LoginListResponse, SyncState } from './protocol/types'
-import type { KakaoChat, KakaoDeviceType, KakaoMessage, KakaoProfile, KakaoSendResult } from './types'
+import type { KakaoChat, KakaoDeviceType, KakaoMember, KakaoMessage, KakaoProfile, KakaoSendResult } from './types'
 
 export type KakaoSessionEvent =
   | { type: 'connected'; userId: string }
@@ -37,6 +37,58 @@ interface SessionState {
   loginResult: LoginListResponse
 }
 
+class MemberNameCache {
+  private byChatId = new Map<string, Map<number, string>>()
+
+  ingest(chatDatas: readonly ChatData[]): void {
+    for (const chat of chatDatas) {
+      const ids = chat.i as Array<{ low: number; high: number } | number> | undefined
+      const names = chat.k as string[] | undefined
+      if (!Array.isArray(ids) || !Array.isArray(names)) continue
+
+      const chatId = String(chat.c)
+      let map = this.byChatId.get(chatId)
+      if (!map) {
+        map = new Map()
+        this.byChatId.set(chatId, map)
+      }
+
+      const len = Math.min(ids.length, names.length)
+      for (let i = 0; i < len; i++) {
+        const numericId = toNumericUserId(ids[i])
+        if (numericId === null) continue
+        const name = names[i]
+        if (typeof name === 'string' && name.length > 0) {
+          map.set(numericId, name)
+        }
+      }
+    }
+  }
+
+  lookup(chatId: string, userId: number): string | null {
+    return this.byChatId.get(chatId)?.get(userId) ?? null
+  }
+
+  forget(chatId: string): void {
+    this.byChatId.delete(chatId)
+  }
+
+  clear(): void {
+    this.byChatId.clear()
+  }
+}
+
+function toNumericUserId(v: unknown): number | null {
+  if (typeof v === 'number') return Number.isFinite(v) ? v : null
+  if (v && typeof v === 'object' && 'low' in v && 'high' in v) {
+    const { low, high } = v as { low: number; high: number }
+    // chatDatas[].i entries are member user IDs. KakaoTalk user IDs fit in
+    // 53 bits — safe to flatten the BSON Long pair to a JS number for keying.
+    return (high >>> 0) * 0x100000000 + (low >>> 0)
+  }
+  return null
+}
+
 function bsonToLong(v: unknown): Long | undefined {
   if (v && typeof v === 'object' && 'high' in v && 'low' in v) {
     const { high, low } = v as { high: number; low: number }
@@ -60,20 +112,39 @@ function parseLong(s: string): Long {
   return new Long(low, high)
 }
 
-function formatChat(chat: ChatData): KakaoChat {
+function parseChatId(chatId: string): Long {
+  try {
+    return parseLong(chatId)
+  } catch (cause) {
+    throw new KakaoTalkError(`Invalid chatId: ${chatId}`, 'invalid_chat_id', { cause })
+  }
+}
+
+function parseUserId(userId: string): Long {
+  try {
+    return parseLong(userId)
+  } catch (cause) {
+    throw new KakaoTalkError(`Invalid userId: ${userId}`, 'invalid_user_id', { cause })
+  }
+}
+
+function formatChat(chat: ChatData, title: string | null, nameCache: MemberNameCache): KakaoChat {
   const memberNames = (chat.k ?? []) as string[]
   const lastLog = chat.l as Record<string, unknown> | null
   const displayName = memberNames.join(', ') || null
+  const chatId = String(chat.c)
 
   return {
-    chat_id: String(chat.c),
+    chat_id: chatId,
     type: chat.t as number,
     display_name: displayName,
+    title,
     active_members: chat.a as number,
     unread_count: chat.n as number,
     last_message: lastLog
       ? {
           author_id: lastLog.authorId as number,
+          author_name: nameCache.lookup(chatId, lastLog.authorId as number),
           message: lastLog.message as string,
           sent_at: lastLog.sendAt as number,
         }
@@ -81,6 +152,50 @@ function formatChat(chat: ChatData): KakaoChat {
   }
 }
 
+const META_TYPE_TITLE = 3
+
+interface ChannelMetaEntry {
+  type?: number
+  content?: string
+}
+
+interface ChannelInfoResponse {
+  chatInfo?: {
+    chatMetas?: ChannelMetaEntry[]
+  }
+}
+
+function extractTitle(body: Record<string, unknown>): string | null {
+  const info = (body as ChannelInfoResponse).chatInfo
+  const metas = info?.chatMetas
+  if (!Array.isArray(metas)) return null
+
+  const titleMeta = metas.find((m) => m?.type === META_TYPE_TITLE)
+  const content = titleMeta?.content
+  return typeof content === 'string' && content.length > 0 ? content : null
+}
+
+interface OpenLinkInfoResponse {
+  ols?: Array<{ ln?: unknown }>
+}
+
+function extractOpenLinkName(body: Record<string, unknown>): string | null {
+  const ols = (body as OpenLinkInfoResponse).ols
+  if (!Array.isArray(ols) || ols.length === 0) return null
+  const ln = ols[0]?.ln
+  return typeof ln === 'string' && ln.length > 0 ? ln : null
+}
+
+const OPEN_CHAT_TYPES = new Set(['OM', 'OD'])
+
+function isOpenChat(chat: ChatData): boolean {
+  return typeof chat.t === 'string' && OPEN_CHAT_TYPES.has(chat.t)
+}
+
+function getOpenLinkId(chat: ChatData): Long | null {
+  return bsonToLong(chat.li) ?? null
+}
+
 function matchesSearch(chat: ChatData, term: string): boolean {
   const names = (chat.k ?? []) as string[]
   const lower = term.toLowerCase()
@@ -222,13 +337,66 @@ function mergeSyncState(previous: SyncState | undefined, loginResult: LoginListR
   return next
 }
 
-function formatMessages(logs: Array<Record<string, unknown>>, count: number): KakaoMessage[] {
+function nullableString(v: unknown): string | null {
+  return typeof v === 'string' && v.length > 0 ? v : null
+}
+
+function nullableNumber(v: unknown): number | null {
+  return typeof v === 'number' && Number.isFinite(v) ? v : null
+}
+
+function isNonZeroLong(v: unknown): boolean {
+  if (typeof v === 'number') return v !== 0
+  if (v && typeof v === 'object' && 'low' in v && 'high' in v) {
+    const { low, high } = v as { low: number; high: number }
+    return low !== 0 || high !== 0
+  }
+  return v !== undefined && v !== null
+}
+
+// Reject synthetic LocoConnection close packets ({ statusCode: -1, body.error: 'connection closed' })
+// and explicit body-level failures. Required for any SDK method whose response body has no
+// caller-visible error channel (e.g. GETMEM/MEMBER return `[]` for both empty rooms and dead
+// sockets). Throwing here lets executeWithReconnect detect session death and reconnect.
+function assertLocoOk(response: LocoPacket, command: string): void {
+  if (response.statusCode !== 0) {
+    throw new Error(`${command} failed: statusCode=${response.statusCode}`)
+  }
+  const bodyStatus = response.body.status
+  if (typeof bodyStatus === 'number' && bodyStatus !== 0) {
+    throw new Error(`${command} failed: body.status=${bodyStatus}`)
+  }
+}
+
+function formatMember(member: Record<string, unknown>): KakaoMember {
+  return {
+    user_id: longToString(member.userId),
+    nickname: typeof member.nickName === 'string' ? member.nickName : '',
+    profile_image_url: nullableString(member.profileImageUrl ?? member.pi),
+    full_profile_image_url: nullableString(member.fullProfileImageUrl ?? member.fpi),
+    original_profile_image_url: nullableString(member.originalProfileImageUrl ?? member.opi),
+    status_message: nullableString(member.statusMessage),
+    country_iso: nullableString(member.countryIso),
+    user_type: nullableNumber(member.type),
+    open_token: nullableNumber(member.opt),
+    open_profile_link_id: isNonZeroLong(member.pli) ? longToString(member.pli) : null,
+    open_permission: nullableNumber(member.mt),
+  }
+}
+
+function formatMessages(
+  logs: Array<Record<string, unknown>>,
+  count: number,
+  chatId: string,
+  nameCache: MemberNameCache,
+): KakaoMessage[] {
   logs.sort((a, b) => (a.sendAt as number) - (b.sendAt as number))
 
   return logs.slice(-count).map((log) => ({
     log_id: longToString(log.logId),
     type: log.type as number,
     author_id: log.authorId as number,
+    author_name: nameCache.lookup(chatId, log.authorId as number),
     message: log.message as string,
     sent_at: log.sendAt as number,
   }))
@@ -244,6 +412,7 @@ export class KakaoTalkClient {
   private closed = false
   private pushHandlers = new Set<KakaoPushHandler>()
   private sessionEventHandlers = new Set<KakaoSessionEventHandler>()
+  private nameCache = new MemberNameCache()
 
   async login(
     credentials?: { oauthToken: string; userId: string; deviceUuid?: string; deviceType?: KakaoDeviceType },
@@ -385,6 +554,8 @@ export class KakaoTalkClient {
       const newSyncState = mergeSyncState(syncState, loginResult)
       await saveSyncState(this.deviceUuid!, newSyncState)
 
+      this.nameCache.ingest((loginResult.chatDatas ?? []) as ChatData[])
+
       return { session, loginResult }
     } catch (error) {
       session.close()
@@ -446,7 +617,7 @@ export class KakaoTalkClient {
     }
   }
 
-  async getChats(options?: { all?: boolean; search?: string }): Promise<KakaoChat[]> {
+  async getChats(options?: { all?: boolean; search?: string; resolveTitles?: boolean }): Promise<KakaoChat[]> {
     return this.executeWithReconnect(async ({ session, loginResult }) => {
       try {
         const allChats: ChatData[] = []
@@ -480,6 +651,7 @@ export class KakaoTalkClient {
             if (chatDatas.length === 0) break
 
             collectChats(chatDatas, allChats, seenChatIds)
+            this.nameCache.ingest(chatDatas)
             cursor = body
             pages++
           }
@@ -492,13 +664,58 @@ export class KakaoTalkClient {
           results = allChats.filter((c) => matchesSearch(c, options.search!))
         }
 
-        return results.map(formatChat)
+        const titles = options?.resolveTitles
+          ? await Promise.all(results.map((chat) => this.fetchChatTitle(session, parseLong(String(chat.c)), chat)))
+          : null
+
+        return results.map((chat, i) => formatChat(chat, titles ? titles[i] : null, this.nameCache))
       } catch (error) {
         throw wrapError(error, 'get_chats_failed')
       }
     })
   }
 
+  /**
+   * Resolve the user-set room title via CHATINFO. Returns null on any error
+   * (network, malformed response, or no TITLE meta present). Designed to be
+   * fire-and-forget per chat — failures don't poison the whole `getChats` call.
+   */
+  async getChatTitle(chatId: string): Promise<string | null> {
+    let parsed: Long
+    try {
+      parsed = parseLong(chatId)
+    } catch {
+      return null
+    }
+    return this.executeWithReconnect(async ({ session, loginResult }) => {
+      const chat = (loginResult.chatDatas ?? []).find((c) => String(c.c) === chatId)
+      return this.fetchChatTitle(session, parsed, chat)
+    })
+  }
+
+  private async fetchChatTitle(session: LocoSession, chatId: Long, chat: ChatData | undefined): Promise<string | null> {
+    let title: string | null = null
+    try {
+      const response = await session.getChannelInfo(chatId)
+      title = extractTitle(response.body as Record<string, unknown>)
+    } catch {
+      title = null
+    }
+
+    if (title) return title
+    if (!chat || !isOpenChat(chat)) return null
+
+    const linkId = getOpenLinkId(chat)
+    if (!linkId) return null
+
+    try {
+      const response = await session.getOpenLinkInfo([linkId])
+      return extractOpenLinkName(response.body as Record<string, unknown>)
+    } catch {
+      return null
+    }
+  }
+
   async getMessages(chatId: string, options?: { count?: number; from?: string }): Promise<KakaoMessage[]> {
     return this.executeWithReconnect(async ({ session }) => {
       try {
@@ -523,7 +740,7 @@ export class KakaoTalkClient {
               (log) => longToString(log.chatId) === chatId,
             )
             if (batch.length === 0) {
-              return formatMessages(allMessages, count)
+              return formatMessages(allMessages, count, chatId, this.nameCache)
             }
 
             for (const log of batch) {
@@ -536,7 +753,7 @@ export class KakaoTalkClient {
 
             const maxLog = findMaxLogId(batch, 'logId')
             if (!maxLog || maxLog.equals(cur) || response.body.eof) {
-              return formatMessages(allMessages, count)
+              return formatMessages(allMessages, count, chatId, this.nameCache)
             }
 
             cur = maxLog
@@ -549,7 +766,7 @@ export class KakaoTalkClient {
 
         if (allMessages.length > 0) {
           warn(`[agent-kakaotalk] Warning: message fetch capped at ${MAX_PAGES} pages. Results may be incomplete.`)
-          return formatMessages(allMessages, count)
+          return formatMessages(allMessages, count, chatId, this.nameCache)
         }
 
         // Fetch fresh lastLogId via CHATONROOM (not the stale login-time snapshot)
@@ -586,13 +803,43 @@ export class KakaoTalkClient {
           warn(`[agent-kakaotalk] Warning: message fetch capped at ${MAX_PAGES} pages. Results may be incomplete.`)
         }
 
-        return formatMessages(allMessages, count)
+        return formatMessages(allMessages, count, chatId, this.nameCache)
       } catch (error) {
         throw wrapError(error, 'get_messages_failed')
       }
     })
   }
 
+  async getMembers(chatId: string): Promise<KakaoMember[]> {
+    const parsedChatId = parseChatId(chatId)
+    return this.executeWithReconnect(async ({ session }) => {
+      try {
+        const response = await session.getAllMembers(parsedChatId)
+        assertLocoOk(response, 'GETMEM')
+        const members = (response.body.members ?? []) as Array<Record<string, unknown>>
+        return members.map(formatMember)
+      } catch (error) {
+        throw wrapError(error, 'get_members_failed')
+      }
+    })
+  }
+
+  async getMembersByIds(chatId: string, userIds: string[]): Promise<KakaoMember[]> {
+    if (userIds.length === 0) return []
+    const parsedChatId = parseChatId(chatId)
+    const memberIds = userIds.map((id) => parseUserId(id))
+    return this.executeWithReconnect(async ({ session }) => {
+      try {
+        const response = await session.getMembersByIds(parsedChatId, memberIds)
+        assertLocoOk(response, 'MEMBER')
+        const members = (response.body.members ?? []) as Array<Record<string, unknown>>
+        return members.map(formatMember)
+      } catch (error) {
+        throw wrapError(error, 'get_members_failed')
+      }
+    })
+  }
+
   async sendMessage(chatId: string, text: string): Promise<KakaoSendResult> {
     return this.executeWithReconnect(async ({ session }) => {
       try {
@@ -683,5 +930,10 @@ export class KakaoTalkClient {
     this.initPromise = null
     this.pushHandlers.clear()
     this.sessionEventHandlers.clear()
+    this.nameCache.clear()
+  }
+
+  lookupAuthorName(chatId: string, authorId: number): string | null {
+    return this.nameCache.lookup(chatId, authorId)
   }
 }

package/src/platforms/kakaotalk/commands/chat.ts

@@ -9,11 +9,12 @@ async function listAction(options: {
   account?: string
   all?: boolean
   search?: string
+  resolveTitles?: boolean
   pretty?: boolean
 }): Promise<void> {
   try {
     const chats = await withKakaoClient(options, (client) =>
-      client.getChats({ all: options.all, search: options.search }),
+      client.getChats({ all: options.all, search: options.search, resolveTitles: options.resolveTitles }),
     )
     console.log(formatOutput(chats, options.pretty))
   } catch (error) {
@@ -29,6 +30,7 @@ export const chatCommand = new Command('chat')
       .option('--account <id>', 'Use a specific KakaoTalk account')
       .option('--all', 'Fetch all chats (paginate beyond login snapshot)')
       .option('--search <name>', 'Search for a chat by display name')
+      .option('--resolve-titles', 'Fetch user-set room titles via CHATINFO (slower; one extra LOCO call per chat)')
       .option('--pretty', 'Pretty print JSON output')
       .action(listAction),
   )

package/src/platforms/kakaotalk/commands/index.ts

@@ -1,4 +1,5 @@
 export { authCommand } from './auth'
 export { chatCommand } from './chat'
+export { memberCommand } from './member'
 export { messageCommand } from './message'
 export { whoamiCommand } from './whoami'

package/src/platforms/kakaotalk/commands/member.test.ts

@@ -0,0 +1,102 @@
+import { afterEach, beforeEach, describe, expect, mock, it } from 'bun:test'
+
+const originalConsoleLog = console.log
+
+const mockWithKakaoClient = mock(async (_options: unknown, fn: (client: unknown) => Promise<unknown>) => {
+  return fn(mockClient)
+})
+
+const mockGetMembers = mock(() =>
+  Promise.resolve([
+    {
+      user_id: '42',
+      nickname: 'Alice',
+      profile_image_url: null,
+      full_profile_image_url: null,
+      original_profile_image_url: null,
+      status_message: null,
+      country_iso: null,
+      user_type: 100,
+      open_token: null,
+      open_profile_link_id: null,
+      open_permission: null,
+    },
+  ]),
+)
+
+const mockClient = {
+  getMembers: mockGetMembers,
+}
+
+mock.module('./shared', () => ({
+  withKakaoClient: mockWithKakaoClient,
+}))
+
+import { memberCommand } from './member'
+
+describe('member commands', () => {
+  let consoleLogSpy: ReturnType<typeof mock>
+
+  beforeEach(() => {
+    mockWithKakaoClient.mockReset()
+    mockGetMembers.mockReset()
+
+    mockWithKakaoClient.mockImplementation(async (_options: unknown, fn: (client: unknown) => Promise<unknown>) => {
+      return fn(mockClient)
+    })
+    mockGetMembers.mockImplementation(() =>
+      Promise.resolve([
+        {
+          user_id: '42',
+          nickname: 'Alice',
+          profile_image_url: null,
+          full_profile_image_url: null,
+          original_profile_image_url: null,
+          status_message: null,
+          country_iso: null,
+          user_type: 100,
+          open_token: null,
+          open_profile_link_id: null,
+          open_permission: null,
+        },
+      ]),
+    )
+
+    consoleLogSpy = mock((..._args: unknown[]) => {})
+    console.log = consoleLogSpy
+  })
+
+  afterEach(() => {
+    console.log = originalConsoleLog
+  })
+
+  describe('list', () => {
+    it('lists members of a chat room', async () => {
+      await memberCommand.parseAsync(['list', '9876543210'], { from: 'user' })
+
+      expect(mockGetMembers).toHaveBeenCalledWith('9876543210')
+      const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+      expect(output).toHaveLength(1)
+      expect(output[0].user_id).toBe('42')
+      expect(output[0].nickname).toBe('Alice')
+    })
+
+    it('passes --account option to withKakaoClient', async () => {
+      await memberCommand.parseAsync(['list', '9876543210', '--account', 'my-account'], { from: 'user' })
+
+      expect(mockWithKakaoClient).toHaveBeenCalledWith(
+        expect.objectContaining({ account: 'my-account' }),
+        expect.any(Function),
+      )
+    })
+
+    it('outputs empty array when chat has no members', async () => {
+      mockGetMembers.mockImplementation(() => Promise.resolve([]))
+
+      await memberCommand.parseAsync(['list', '9876543210'], { from: 'user' })
+
+      const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+      expect(output).toEqual([])
+    })
+  })
+})

package/src/platforms/kakaotalk/commands/member.ts

@@ -0,0 +1,32 @@
+import { Command } from 'commander'
+
+import { handleError } from '@/shared/utils/error-handler'
+import { formatOutput } from '@/shared/utils/output'
+
+import { withKakaoClient } from './shared'
+
+async function listAction(
+  chatId: string,
+  options: {
+    account?: string
+    pretty?: boolean
+  },
+): Promise<void> {
+  try {
+    const members = await withKakaoClient(options, (client) => client.getMembers(chatId))
+    console.log(formatOutput(members, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export const memberCommand = new Command('member')
+  .description('KakaoTalk member commands')
+  .addCommand(
+    new Command('list')
+      .description('List members of a chat room')
+      .argument('<chat-id>', 'Chat room ID')
+      .option('--account <id>', 'Use a specific KakaoTalk account')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(listAction),
+  )

package/src/platforms/kakaotalk/index.test.ts

@@ -1,6 +1,7 @@
 import { expect, it } from 'bun:test'
 
 import {
+  classifyKakaoChat,
   CredentialManager,
   KakaoAccountCredentialsSchema,
   KakaoCredentialManager,
@@ -72,3 +73,7 @@ it('KakaoTalkPushReadEventSchema is exported from barrel', () => {
 it('KakaoProfileSchema is exported from barrel', () => {
   expect(typeof KakaoProfileSchema.parse).toBe('function')
 })
+
+it('classifyKakaoChat is exported from barrel', () => {
+  expect(typeof classifyKakaoChat).toBe('function')
+})

package/src/platforms/kakaotalk/index.ts

@@ -1,4 +1,6 @@
 export { KakaoTalkClient, KakaoTalkError } from './client'
+export { classifyKakaoChat } from './chat-classifier'
+export type { KakaoChatKind } from './chat-classifier'
 export { KakaoCredentialManager, CredentialManager } from './credential-manager'
 export { KakaoTalkListener } from './listener'
 export type { PendingLoginState } from './credential-manager'
@@ -8,6 +10,7 @@ export type {
   KakaoChat,
   KakaoConfig,
   KakaoDeviceType,
+  KakaoMember,
   KakaoMessage,
   KakaoProfile,
   KakaoSendResult,
@@ -22,6 +25,7 @@ export {
   KakaoAccountCredentialsSchema,
   KakaoChatSchema,
   KakaoConfigSchema,
+  KakaoMemberSchema,
   KakaoMessageSchema,
   KakaoProfileSchema,
   KakaoSendResultSchema,

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

@@ -16,6 +16,7 @@ class FakeClient {
   sessionHandlers = new Set<KakaoSessionEventHandler>()
   acquireImpl: () => Promise<void> = async () => {}
   connected = false
+  lookupAuthorName: (chatId: string, authorId: number) => string | null = () => null
 
   async acquireSession(): Promise<unknown> {
     this.acquireCalls++
@@ -141,10 +142,38 @@ describe('KakaoTalkListener', () => {
       expect(messages[0].chat_id).toBe('100')
       expect(messages[0].log_id).toBe('200')
       expect(messages[0].author_id).toBe(42)
+      expect(messages[0].author_name).toBeNull()
       expect(messages[0].message).toBe('hello world')
       expect(messages[0].message_type).toBe(1)
       expect(messages[0].sent_at).toBe(1700000000)
     })
+
+    it('resolves author_name from client.lookupAuthorName when available', async () => {
+      const { listener: l, client } = createListener()
+      listener = l
+
+      client.lookupAuthorName = (chatId: string, authorId: number) => {
+        if (chatId === '100' && authorId === 42) return 'Alice'
+        return null
+      }
+
+      const messages: KakaoTalkPushMessageEvent[] = []
+      listener.on('message', (event) => messages.push(event))
+
+      await listener.start()
+      client.emitPush('MSG', {
+        chatId: { high: 0, low: 100 },
+        chatLog: {
+          logId: { high: 0, low: 200 },
+          authorId: 42,
+          message: 'hello',
+          type: 1,
+          sendAt: 1700000000,
+        },
+      })
+
+      expect(messages[0].author_name).toBe('Alice')
+    })
   })
 
   describe('member events', () => {

package/src/platforms/kakaotalk/listener.ts

@@ -109,11 +109,14 @@ export class KakaoTalkListener {
     switch (method) {
       case 'MSG': {
         const chatLog = body.chatLog as Record<string, unknown>
+        const chatId = longToString(body.chatId)
+        const authorId = chatLog.authorId as number
         const event: KakaoTalkPushMessageEvent = {
           type: 'MSG',
-          chat_id: longToString(body.chatId),
+          chat_id: chatId,
           log_id: longToString(chatLog.logId),
-          author_id: chatLog.authorId as number,
+          author_id: authorId,
+          author_name: this.client.lookupAuthorName?.(chatId, authorId) ?? null,
           message: chatLog.message as string,
           message_type: chatLog.type as number,
           sent_at: chatLog.sendAt as number,