agent-messenger 2.29.1 → 2.31.0

package/src/platforms/slack/commands/message.test.ts

@@ -165,17 +165,17 @@ describe('Message Commands', () => {
     })
   })
 
-  describe('message update', () => {
-    it('updates message text', async () => {
+  describe('message edit', () => {
+    it('edits message text', async () => {
       // Given: A channel, message ts, and new text
       const channel = 'C123'
       const ts = '1234567890.123456'
       const newText = 'Updated message'
 
-      // When: Updating message
+      // When: Editing message
       const result = await mockClient.updateMessage(channel, ts, newText)
 
-      // Then: Should return updated message
+      // Then: Should return edited message
       expect(result.ts).toBe(ts)
       expect(result.text).toBe(newText)
     })

package/src/platforms/slack/commands/message.ts

@@ -114,7 +114,7 @@ async function getAction(channelInput: string, ts: string, options: { pretty?: b
   }
 }
 
-async function updateAction(
+async function editAction(
   channelInput: string,
   ts: string,
   text: string,
@@ -413,13 +413,13 @@ export const messageCommand = new Command('message')
       .action(getAction),
   )
   .addCommand(
-    new Command('update')
-      .description('Update message text')
+    new Command('edit')
+      .description('Edit message text')
       .argument('<channel>', 'Channel ID or name')
       .argument('<ts>', 'Message timestamp')
       .argument('<text>', 'New message text')
       .option('--pretty', 'Pretty print JSON output')
-      .action(updateAction),
+      .action(editAction),
   )
   .addCommand(
     new Command('delete')

package/src/platforms/slackbot/commands/message.ts

@@ -59,7 +59,7 @@ async function getAction(channelInput: string, ts: string, options: BotOption):
   }
 }
 
-async function updateAction(channelInput: string, ts: string, text: string, options: BotOption): Promise<void> {
+async function editAction(channelInput: string, ts: string, text: string, options: BotOption): Promise<void> {
   try {
     const client = await getClient(options)
     const channel = await client.resolveChannel(channelInput)
@@ -158,14 +158,14 @@ export const messageCommand = new Command('message')
       .action(getAction),
   )
   .addCommand(
-    new Command('update')
-      .description('Update a message')
+    new Command('edit')
+      .description('Edit a message')
       .argument('<channel>', 'Channel ID or name')
       .argument('<ts>', 'Message timestamp')
       .argument('<text>', 'New message text')
       .option('--bot <id>', 'Use specific bot')
       .option('--pretty', 'Pretty print JSON output')
-      .action(updateAction),
+      .action(editAction),
   )
   .addCommand(
     new Command('delete')

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

@@ -330,6 +330,30 @@ describe('TeamsClient', () => {
     })
   })
 
+  describe('editChatMessage', () => {
+    it('PUTs an HTML-escaped edit to a chat message', async () => {
+      mockResponse({ edittime: 1704067200000 })
+
+      const client = await new TeamsClient().login({ token: 'test-token', accountType: 'personal' })
+      const message = await client.editChatMessage('19:1on1@unq.gbl.spaces', 'msg1', 'a <b> & c')
+
+      expect(message.id).toBe('msg1')
+      expect(message.content).toBe('a <b> & c')
+      expect(fetchCalls[0].url).toBe(
+        'https://msgapi.teams.live.com/v1/users/ME/conversations/19%3A1on1%40unq.gbl.spaces/messages/msg1',
+      )
+      expect(fetchCalls[0].options?.method).toBe('PUT')
+      expect(fetchCalls[0].options?.body).toBe(
+        JSON.stringify({
+          content: 'a &lt;b&gt; &amp; c',
+          messagetype: 'RichText/Html',
+          contenttype: 'text',
+          skypeeditedid: 'msg1',
+        }),
+      )
+    })
+  })
+
   describe('getTeam', () => {
     it('returns team info', async () => {
       mockResponse({ id: '111', name: 'Test Team', description: 'A test team' })

package/src/platforms/teams/client.ts

@@ -713,6 +713,34 @@ export class TeamsClient {
     }
   }
 
+  async editChatMessage(chatId: string, messageId: string, content: string): Promise<TeamsMessage> {
+    interface EditResponse {
+      edittime?: string | number
+    }
+    const encodedChatId = encodeURIComponent(chatId)
+    const encodedMessageId = encodeURIComponent(messageId)
+    // Skype messaging backend requires skypeeditedid to duplicate the URL message id.
+    const response = await this.request<EditResponse>(
+      'PUT',
+      `/users/ME/conversations/${encodedChatId}/messages/${encodedMessageId}`,
+      {
+        content: escapeHtml(content),
+        messagetype: 'RichText/Html',
+        contenttype: 'text',
+        skypeeditedid: messageId,
+      },
+    )
+
+    const editTime = response?.edittime
+    return {
+      id: messageId,
+      channel_id: chatId,
+      author: { id: 'ME', displayName: 'Me' },
+      content,
+      timestamp: editTime ? new Date(Number(editTime) || editTime).toISOString() : new Date().toISOString(),
+    }
+  }
+
   async getTeam(teamId: string): Promise<TeamsTeam> {
     return this.request<TeamsTeam>('GET', `/csa/api/v1/teams/${teamId}`, undefined, CSA_API_BASE)
   }

package/src/platforms/teams/commands/chat.test.ts

@@ -2,11 +2,12 @@ import { afterEach, beforeEach, expect, mock, spyOn, it } from 'bun:test'
 
 import { TeamsClient } from '../client'
 import { TeamsCredentialManager } from '../credential-manager'
-import { historyAction, listAction, sendAction } from './chat'
+import { editAction, historyAction, listAction, sendAction } from './chat'
 
 let clientListChatsSpy: ReturnType<typeof spyOn>
 let clientGetChatMessagesSpy: ReturnType<typeof spyOn>
 let clientSendChatMessageSpy: ReturnType<typeof spyOn>
+let clientEditChatMessageSpy: ReturnType<typeof spyOn>
 let credManagerLoadSpy: ReturnType<typeof spyOn>
 const originalConsoleLog = console.log
 
@@ -34,6 +35,14 @@ beforeEach(() => {
     timestamp: '2025-01-29T10:00:00Z',
   })
 
+  clientEditChatMessageSpy = spyOn(TeamsClient.prototype, 'editChatMessage').mockResolvedValue({
+    id: 'msg_123',
+    channel_id: '19:1on1@unq.gbl.spaces',
+    author: { id: 'ME', displayName: 'Me' },
+    content: 'Edited content',
+    timestamp: '2025-01-29T10:05:00Z',
+  })
+
   credManagerLoadSpy = spyOn(TeamsCredentialManager.prototype, 'loadConfig').mockResolvedValue({
     current_account: 'personal',
     accounts: {
@@ -51,6 +60,7 @@ afterEach(() => {
   clientListChatsSpy?.mockRestore()
   clientGetChatMessagesSpy?.mockRestore()
   clientSendChatMessageSpy?.mockRestore()
+  clientEditChatMessageSpy?.mockRestore()
   credManagerLoadSpy?.mockRestore()
   console.log = originalConsoleLog
 })
@@ -98,3 +108,15 @@ it('send: returns sent message', async () => {
   const output = consoleSpy.mock.calls[0][0]
   expect(output).toContain('Hello world')
 })
+
+it('edit: edits a chat message and returns updated content', async () => {
+  const consoleSpy = mock((_msg: string) => {})
+  console.log = consoleSpy
+
+  await editAction('19:1on1@unq.gbl.spaces', 'msg_123', 'Edited content', { pretty: false })
+
+  expect(clientEditChatMessageSpy).toHaveBeenCalledWith('19:1on1@unq.gbl.spaces', 'msg_123', 'Edited content')
+  expect(consoleSpy).toHaveBeenCalled()
+  const output = consoleSpy.mock.calls[0][0]
+  expect(output).toContain('Edited content')
+})

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

@@ -100,6 +100,41 @@ export async function sendAction(chatId: string, content: string, options: { pre
   }
 }
 
+export async function editAction(
+  chatId: string,
+  messageId: string,
+  content: string,
+  options: { pretty?: boolean },
+): Promise<void> {
+  try {
+    const credManager = new TeamsCredentialManager()
+    const cred = await credManager.getTokenWithExpiry()
+
+    if (!cred) {
+      console.log(formatOutput({ error: 'Not authenticated. Run "auth extract" first.' }, options.pretty))
+      process.exit(1)
+    }
+
+    const client = await new TeamsClient().login({
+      token: cred.token,
+      tokenExpiresAt: cred.tokenExpiresAt,
+      accountType: cred.accountType,
+      region: cred.region,
+    })
+    const message = await client.editChatMessage(chatId, messageId, content)
+
+    const output = {
+      id: message.id,
+      content: message.content,
+      timestamp: message.timestamp,
+    }
+
+    console.log(formatOutput(output, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
 export const chatCommand = new Command('chat')
   .description('Chat commands (1:1, group, and self chats)')
   .addCommand(
@@ -129,3 +164,12 @@ export const chatCommand = new Command('chat')
       .option('--pretty', 'Pretty print JSON output')
       .action(sendAction),
   )
+  .addCommand(
+    new Command('edit')
+      .description('Edit a message in a chat (your own messages only)')
+      .argument('<chat-id>', 'Chat ID')
+      .argument('<message-id>', 'Message ID')
+      .argument('<content>', 'New message content')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(editAction),
+  )

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

@@ -235,3 +235,63 @@ describe('sendMessage confirmation', () => {
     expect(result.id).toBe(serverId)
   })
 })
+
+describe('editMessage', () => {
+  it('returns the edited message from the editMessageText response', async () => {
+    const events: any[] = []
+    let editRequest: any = null
+
+    const createClientId = mock(() => 1)
+    const send = mock((_clientId: number, request: any) => {
+      if (request['@type'] === 'getAuthorizationState') {
+        events.push({
+          '@type': 'updateAuthorizationState',
+          authorization_state: { '@type': 'authorizationStateReady' },
+          '@extra': request['@extra'],
+        })
+      }
+
+      if (request['@type'] === 'getChat') {
+        events.push({ '@type': 'chat', id: 42, title: 'test', unread_count: 0, '@extra': request['@extra'] })
+      }
+
+      if (request['@type'] === 'editMessageText') {
+        editRequest = request
+        events.push({
+          '@type': 'message',
+          id: 555,
+          chat_id: 42,
+          date: 1_710_000_002,
+          is_outgoing: true,
+          sender_id: { '@type': 'messageSenderUser', user_id: 1 },
+          content: {
+            '@type': 'messageText',
+            text: { '@type': 'formattedText', text: 'edited text', entities: [] },
+          },
+          '@extra': request['@extra'],
+        })
+      }
+    })
+
+    const receive = mock(() => events.shift() ?? null)
+    const client = new (TelegramTdlibClient as unknown as new (
+      account: TelegramAccount,
+      paths: TelegramAccountPaths,
+      tdjson: any,
+    ) => TelegramTdlibClient)(mockAccount, mockPaths, {
+      createClientId,
+      send,
+      receive,
+      libraryPath: '/mock/lib',
+    })
+
+    const result = await client.editMessage('42', 555, 'edited text')
+
+    expect(result.id).toBe(555)
+    expect(result.text).toBe('edited text')
+    expect(editRequest.chat_id).toBe(42)
+    expect(editRequest.message_id).toBe(555)
+    expect(editRequest.input_message_content['@type']).toBe('inputMessageText')
+    expect(editRequest.input_message_content.text.text).toBe('edited text')
+  })
+})

package/src/platforms/telegram/client.ts

@@ -312,6 +312,30 @@ export class TelegramTdlibClient {
     return simplifyMessage(message, chat.id)
   }
 
+  async editMessage(reference: string, messageId: number, text: string): Promise<TelegramMessageSummary> {
+    await this.ensureReady()
+    const chat = await this.resolveChat(reference)
+
+    const message = (await this.call({
+      '@type': 'editMessageText',
+      chat_id: chat.id,
+      message_id: messageId,
+      reply_markup: null,
+      input_message_content: {
+        '@type': 'inputMessageText',
+        text: {
+          '@type': 'formattedText',
+          text,
+          entities: [],
+        },
+        link_preview_options: null,
+        clear_draft: false,
+      },
+    })) as TdMessage
+
+    return simplifyMessage(message, chat.id)
+  }
+
   private async ensureReady(): Promise<void> {
     const state = await this.connect()
     if (state?.['@type'] !== 'authorizationStateReady') {

package/src/platforms/telegram/commands/message.test.ts

@@ -9,9 +9,12 @@ const mockListMessages = mock(() =>
 
 const mockSendMessage = mock(() => Promise.resolve({ id: 3, text: 'Sent message', sender_id: 'user-1', date: 3000 }))
 
+const mockEditMessage = mock(() => Promise.resolve({ id: 3, text: 'Edited message', sender_id: 'user-1', date: 3000 }))
+
 const mockClient = {
   listMessages: mockListMessages,
   sendMessage: mockSendMessage,
+  editMessage: mockEditMessage,
 }
 
 mock.module('./shared', () => ({
@@ -36,6 +39,10 @@ describe('message commands', () => {
     mockSendMessage.mockImplementation(() =>
       Promise.resolve({ id: 3, text: 'Sent message', sender_id: 'user-1', date: 3000 }),
     )
+    mockEditMessage.mockReset()
+    mockEditMessage.mockImplementation(() =>
+      Promise.resolve({ id: 3, text: 'Edited message', sender_id: 'user-1', date: 3000 }),
+    )
     consoleSpy = spyOn(console, 'log').mockImplementation(() => {})
     processExitSpy = spyOn(process, 'exit').mockImplementation((() => {}) as (code?: number) => never)
   })
@@ -86,4 +93,35 @@ describe('message commands', () => {
       expect(parsed.id).toBe(3)
     })
   })
+
+  describe('edit subcommand', () => {
+    it('calls editMessage with chat reference, numeric message id, and text', async () => {
+      await messageCommand.parseAsync(['edit', 'chat-123', '3', 'Edited message'], { from: 'user' })
+
+      expect(mockEditMessage).toHaveBeenCalledWith('chat-123', 3, 'Edited message')
+    })
+
+    it('outputs the edited message as JSON', async () => {
+      await messageCommand.parseAsync(['edit', 'chat-123', '3', 'Edited message'], { from: 'user' })
+
+      expect(consoleSpy).toHaveBeenCalled()
+      const output = consoleSpy.mock.calls[0][0] as string
+      const parsed = JSON.parse(output)
+      expect(parsed.text).toBe('Edited message')
+    })
+
+    it('rejects non-decimal, unsafe, or non-positive message ids', async () => {
+      const invalidIds = ['not-a-number', '1e3', '0x10', '0', '9007199254740993']
+
+      for (const invalidId of invalidIds) {
+        mockEditMessage.mockClear()
+        processExitSpy.mockClear()
+
+        await messageCommand.parseAsync(['edit', 'chat-123', invalidId, 'text'], { from: 'user' })
+
+        expect(mockEditMessage).not.toHaveBeenCalled()
+        expect(processExitSpy).toHaveBeenCalledWith(1)
+      }
+    })
+  })
 })

package/src/platforms/telegram/commands/message.ts

@@ -30,6 +30,35 @@ async function sendAction(
   }
 }
 
+async function editAction(
+  reference: string,
+  messageId: string,
+  text: string,
+  options: { account?: string; pretty?: boolean },
+): Promise<void> {
+  try {
+    const trimmedMessageId = messageId.trim()
+    const parsedMessageId = Number.parseInt(trimmedMessageId, 10)
+    if (!/^\d+$/.test(trimmedMessageId) || !Number.isSafeInteger(parsedMessageId) || parsedMessageId <= 0) {
+      console.log(
+        formatOutput(
+          { error: 'Invalid message ID. Provide the numeric message ID from "message list".' },
+          options.pretty,
+        ),
+      )
+      process.exit(1)
+      return
+    }
+
+    const message = await withTelegramClient(options, async (client) =>
+      client.editMessage(reference, parsedMessageId, text),
+    )
+    console.log(formatOutput(message, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
 export const messageCommand = new Command('message')
   .description('Telegram message commands')
   .addCommand(
@@ -50,3 +79,13 @@ export const messageCommand = new Command('message')
       .option('--pretty', 'Pretty print JSON output')
       .action(sendAction),
   )
+  .addCommand(
+    new Command('edit')
+      .description('Edit a text message (your own messages only, within 48h)')
+      .argument('<chat>', 'Chat ID, @username, or title')
+      .argument('<message-id>', 'Message ID')
+      .argument('<text>', 'New message text')
+      .option('--account <id>', 'Use a specific Telegram account')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(editAction),
+  )

package/src/platforms/telegrambot/commands/message.ts

@@ -61,7 +61,7 @@ export async function sendAction(
   }
 }
 
-export async function updateAction(
+export async function editAction(
   chat: string,
   messageId: string,
   text: string,
@@ -162,7 +162,7 @@ export const messageCommand = new Command('message')
       ),
   )
   .addCommand(
-    new Command('update')
+    new Command('edit')
       .description("Edit a message (bot's own messages only)")
       .argument('<chat>', 'Chat ID or @username')
       .argument('<message-id>', 'Message ID')
@@ -177,7 +177,7 @@ export const messageCommand = new Command('message')
           text: string,
           opts: BotOption & { parseMode?: 'HTML' | 'Markdown' | 'MarkdownV2' },
         ) => {
-          cliOutput(await updateAction(chat, messageId, text, opts), opts.pretty)
+          cliOutput(await editAction(chat, messageId, text, opts), opts.pretty)
         },
       ),
   )

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

@@ -0,0 +1,58 @@
+import { describe, expect, it } from 'bun:test'
+
+import type { WAMessage } from '@whiskeysockets/baileys'
+
+import { summarizeMessage } from '@/platforms/whatsapp/client'
+
+describe('summarizeMessage', () => {
+  it('summarizes a plain text message', () => {
+    const msg = {
+      key: { id: 'msg-1', remoteJid: '12025551234@s.whatsapp.net', fromMe: true },
+      messageTimestamp: 1_700_000_000,
+      message: { conversation: 'Hello' },
+    } as unknown as WAMessage
+
+    const summary = summarizeMessage(msg)
+
+    expect(summary.id).toBe('msg-1')
+    expect(summary.type).toBe('text')
+    expect(summary.text).toBe('Hello')
+  })
+
+  it('unwraps a Baileys edit protocolMessage to the edited content', () => {
+    const msg = {
+      key: { id: 'msg-2', remoteJid: '12025551234@s.whatsapp.net', fromMe: true },
+      messageTimestamp: 1_700_000_100,
+      message: {
+        protocolMessage: {
+          type: 14,
+          editedMessage: { conversation: 'Edited text' },
+        },
+      },
+    } as unknown as WAMessage
+
+    const summary = summarizeMessage(msg)
+
+    expect(summary.id).toBe('msg-2')
+    expect(summary.type).toBe('text')
+    expect(summary.text).toBe('Edited text')
+  })
+
+  it('unwraps an edit that uses extendedTextMessage', () => {
+    const msg = {
+      key: { id: 'msg-3', remoteJid: '12025551234@s.whatsapp.net', fromMe: true },
+      messageTimestamp: 1_700_000_200,
+      message: {
+        protocolMessage: {
+          type: 14,
+          editedMessage: { extendedTextMessage: { text: 'Edited via extended' } },
+        },
+      },
+    } as unknown as WAMessage
+
+    const summary = summarizeMessage(msg)
+
+    expect(summary.type).toBe('text')
+    expect(summary.text).toBe('Edited via extended')
+  })
+})

package/src/platforms/whatsapp/client.ts

@@ -48,11 +48,15 @@ function resolveJid(input: string): string {
   return `${digits}@s.whatsapp.net`
 }
 
-function summarizeMessage(msg: WAMessage): WhatsAppMessageSummary {
+export function summarizeMessage(msg: WAMessage): WhatsAppMessageSummary {
   const jid = msg.key.remoteJid ?? ''
   const isGroup = jid.endsWith('@g.us')
   const from = msg.key.fromMe ? '' : isGroup ? (msg.key.participant ?? msg.participant ?? jid) : jid
 
+  // Baileys wraps an edit as a protocolMessage whose editedMessage holds the new
+  // content; unwrap it so the summary reflects the edited text and type.
+  const content = msg.message?.protocolMessage?.editedMessage ?? msg.message
+
   return {
     id: msg.key.id ?? '',
     chat_id: jid,
@@ -60,8 +64,8 @@ function summarizeMessage(msg: WAMessage): WhatsAppMessageSummary {
     from_name: msg.pushName ?? undefined,
     timestamp: new Date(toTimestampMs(msg.messageTimestamp)).toISOString(),
     is_outgoing: Boolean(msg.key.fromMe),
-    type: getMessageType(msg.message),
-    text: extractMessageText(msg.message),
+    type: getMessageType(content),
+    text: extractMessageText(content),
   }
 }
 
@@ -660,6 +664,22 @@ export class WhatsAppClient {
     })
   }
 
+  async editMessage(jid: string, messageId: string, text: string): Promise<WhatsAppMessageSummary> {
+    if (!this.sock) throw new WhatsAppError('Not connected', 'not_connected')
+
+    const resolvedJid = resolveJid(jid)
+    const result = await this.sock.sendMessage(resolvedJid, {
+      text,
+      edit: { remoteJid: resolvedJid, fromMe: true, id: messageId },
+    })
+
+    if (!result) {
+      throw new WhatsAppError('Failed to edit message', 'edit_failed')
+    }
+
+    return summarizeMessage(result)
+  }
+
   async close(): Promise<void> {
     try {
       await this.saveStore()

package/src/platforms/whatsapp/commands/message.test.ts

@@ -42,6 +42,16 @@ const mockSendMessage = mock(() =>
   }),
 )
 
+const mockEditMessage = mock(() =>
+  Promise.resolve({
+    id: 'msg-2',
+    text: 'Edited text',
+    from: 'me@s.whatsapp.net',
+    timestamp: 3000,
+    fromMe: true,
+  }),
+)
+
 const mockSendReaction = mock(() => Promise.resolve())
 const mockConnect = mock(() => Promise.resolve())
 const mockClose = mock(() => Promise.resolve())
@@ -55,6 +65,7 @@ mock.module('../client', () => ({
     close = mockClose
     getMessages = mockGetMessages
     sendMessage = mockSendMessage
+    editMessage = mockEditMessage
     sendReaction = mockSendReaction
   },
 }))
@@ -71,6 +82,7 @@ describe('message commands', () => {
     mockEnsureAccountPaths.mockReset()
     mockGetMessages.mockReset()
     mockSendMessage.mockReset()
+    mockEditMessage.mockReset()
     mockSendReaction.mockReset()
     mockConnect.mockReset()
     mockClose.mockReset()
@@ -107,6 +119,15 @@ describe('message commands', () => {
         fromMe: true,
       }),
     )
+    mockEditMessage.mockImplementation(() =>
+      Promise.resolve({
+        id: 'msg-2',
+        text: 'Edited text',
+        from: 'me@s.whatsapp.net',
+        timestamp: 3000,
+        fromMe: true,
+      }),
+    )
     mockSendReaction.mockImplementation(() => Promise.resolve())
     mockConnect.mockImplementation(() => Promise.resolve())
     mockClose.mockImplementation(() => Promise.resolve())
@@ -182,6 +203,28 @@ describe('message commands', () => {
     })
   })
 
+  describe('edit', () => {
+    it('edits a message in a chat', async () => {
+      await messageCommand.parseAsync(['edit', '12025551234@s.whatsapp.net', 'msg-2', 'Edited text'], { from: 'user' })
+
+      expect(processExitSpy).toHaveBeenCalledWith(0)
+      expect(mockEditMessage).toHaveBeenCalledWith('12025551234@s.whatsapp.net', 'msg-2', 'Edited text')
+      const output = JSON.parse(consoleLogSpy.mock.calls[0][0])
+      expect(output.id).toBe('msg-2')
+      expect(output.text).toBe('Edited text')
+    })
+
+    it('passes account option to credential manager', async () => {
+      await messageCommand.parseAsync(
+        ['edit', '12025551234@s.whatsapp.net', 'msg-2', 'Edited text', '--account', 'my-account'],
+        { from: 'user' },
+      )
+
+      expect(processExitSpy).toHaveBeenCalledWith(0)
+      expect(mockGetAccount).toHaveBeenCalledWith('my-account')
+    })
+  })
+
   describe('react', () => {
     it('sends a reaction to a message', async () => {
       await messageCommand.parseAsync(['react', '12025551234@s.whatsapp.net', 'msg-1', '👍'], { from: 'user' })