agent-messenger 2.17.0 → 2.19.0

package/skills/agent-telegrambot/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: agent-telegrambot
 description: Interact with Telegram using bot tokens - send messages, read chats, manage reactions
-version: 2.17.0
+version: 2.19.0
 allowed-tools: Bash(agent-telegrambot:*)
 metadata:
   openclaw:

package/skills/agent-webex/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: agent-webex
 description: Interact with Cisco Webex - send messages, read spaces, manage memberships
-version: 2.17.0
+version: 2.19.0
 allowed-tools: Bash(agent-webex:*)
 metadata:
   openclaw:
@@ -76,6 +76,37 @@ Note: Messages sent via OAuth Device Grant show "via agent-messenger" because th
 
 Optionally, pass `--token <bot-token>` for bot token auth. Or pass `--client-id <id> --client-secret <secret>` to use your own Webex Integration credentials instead of the built-in ones.
 
+**For AI agents (non-TTY)**: `agent-webex auth login` exposes the OAuth Device Grant flow as a stateless two-call sequence — no hangs, no polling loops, no on-disk state. Just structured JSON every time.
+
+**Call 1** (no `--device-code` passed): the command requests a device code from Webex and returns immediately:
+
+```json
+{
+  "next_action": "authorize_in_browser",
+  "verification_uri": "https://login.webex.com/verify",
+  "verification_uri_complete": "https://login.webex.com/verify?userCode=ABC123",
+  "user_code": "ABC123",
+  "device_code": "d8eb0eca-2fee-428e-a59e-5e6d487b33ba",
+  "expires_at": 1779786537203,
+  "message": "Show the user `verification_uri` and `user_code` ..."
+}
+```
+
+Show the user `verification_uri_complete` (or `verification_uri` + `user_code`) in chat. **Remember the `device_code` value** — you will pass it back on the second call. Ask the user to confirm once they have approved access in any browser, on any device.
+
+**Call 2** (`--device-code <device_code>`): pass the `device_code` from Call 1's response. The command makes one polling call to Webex:
+
+- **Success** — returns `{ "authenticated": true, "user": { ... } }`, exit 0.
+- **Still pending** — returns `{ "next_action": "still_pending", "device_code": "...", ... }`, exit 0. The user has not approved yet; confirm with them and retry with the same `--device-code` value.
+- **Expired / failed** — returns `{ "next_action": "restart", "error": "..." }`, exit 1. The device code is no longer usable; start over with another `agent-webex auth login` (no flags) to get a fresh one.
+
+If you passed `--client-id` / `--client-secret` (custom Webex Integration) on Call 1, pass them again on Call 2.
+
+Alternatives that skip the Device Grant flow entirely:
+
+- `agent-webex auth login --token <bot-or-personal-access-token>` — fully unattended, no human required.
+- `agent-webex auth extract` — read an existing browser session token (no auth flow at all).
+
 Env vars `AGENT_WEBEX_CLIENT_ID` / `AGENT_WEBEX_CLIENT_SECRET` can also override the built-in credentials.
 
 ```bash

package/skills/agent-wechatbot/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: agent-wechatbot
 description: Interact with WeChat Official Account using API credentials - send messages, manage templates, list followers
-version: 2.17.0
+version: 2.19.0
 allowed-tools: Bash(agent-wechatbot:*)
 metadata:
   openclaw:

package/skills/agent-whatsapp/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: agent-whatsapp
 description: Interact with WhatsApp - send messages, read chats, manage conversations
-version: 2.17.0
+version: 2.19.0
 allowed-tools: Bash(agent-whatsapp:*)
 metadata:
   openclaw:

package/skills/agent-whatsappbot/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: agent-whatsappbot
 description: Interact with WhatsApp using Cloud API credentials - send messages, manage templates
-version: 2.17.0
+version: 2.19.0
 allowed-tools: Bash(agent-whatsappbot:*)
 metadata:
   openclaw:

package/src/platforms/discord/commands/dm.test.ts

@@ -5,6 +5,12 @@ import { DiscordCredentialManager } from '../credential-manager'
 import type { DiscordDMChannel } from '../types'
 import { createAction, listAction } from './dm'
 
+class ProcessExit extends Error {
+  constructor(readonly code?: string | number | null) {
+    super(`process.exit(${code})`)
+  }
+}
+
 let clientListDMChannelsSpy: ReturnType<typeof spyOn>
 let clientCreateDMSpy: ReturnType<typeof spyOn>
 let credManagerLoadSpy: ReturnType<typeof spyOn>
@@ -86,21 +92,22 @@ describe('dm commands', () => {
         servers: {},
       })
 
-      const exitSpy = mock(() => {})
-      const originalExit = process.exit
-      process.exit = exitSpy as any
+      const exitSpy = spyOn(process, 'exit').mockImplementation((code?: string | number | null) => {
+        throw new ProcessExit(code)
+      })
 
       const consoleSpy = mock(() => {})
       const originalLog = console.log
       console.log = consoleSpy
 
-      await listAction({ pretty: false })
-
-      console.log = originalLog
-      process.exit = originalExit
-
-      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Not authenticated'))
-      expect(exitSpy).toHaveBeenCalledWith(1)
+      try {
+        await expect(listAction({ pretty: false })).rejects.toThrow(ProcessExit)
+        expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Not authenticated'))
+        expect(exitSpy).toHaveBeenCalledWith(1)
+      } finally {
+        console.log = originalLog
+        exitSpy.mockRestore()
+      }
     })
   })
 
@@ -125,21 +132,22 @@ describe('dm commands', () => {
         servers: {},
       })
 
-      const exitSpy = mock(() => {})
-      const originalExit = process.exit
-      process.exit = exitSpy as any
+      const exitSpy = spyOn(process, 'exit').mockImplementation((code?: string | number | null) => {
+        throw new ProcessExit(code)
+      })
 
       const consoleSpy = mock(() => {})
       const originalLog = console.log
       console.log = consoleSpy
 
-      await createAction('456', { pretty: false })
-
-      console.log = originalLog
-      process.exit = originalExit
-
-      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Not authenticated'))
-      expect(exitSpy).toHaveBeenCalledWith(1)
+      try {
+        await expect(createAction('456', { pretty: false })).rejects.toThrow(ProcessExit)
+        expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Not authenticated'))
+        expect(exitSpy).toHaveBeenCalledWith(1)
+      } finally {
+        console.log = originalLog
+        exitSpy.mockRestore()
+      }
     })
   })
 })

package/src/platforms/discord/commands/reaction.test.ts

@@ -4,6 +4,12 @@ import { DiscordClient } from '../client'
 import { DiscordCredentialManager } from '../credential-manager'
 import { addAction, listAction, removeAction } from './reaction'
 
+class ProcessExit extends Error {
+  constructor(readonly code?: string | number | null) {
+    super(`process.exit(${code})`)
+  }
+}
+
 let clientAddReactionSpy: ReturnType<typeof spyOn>
 let clientRemoveReactionSpy: ReturnType<typeof spyOn>
 let clientGetMessageSpy: ReturnType<typeof spyOn>
@@ -114,21 +120,20 @@ it('add: handles missing token gracefully', async () => {
 
   const consoleSpy = mock((_msg: string) => {})
   const originalLog = console.log
-  const originalExit = process.exit
-  let _exitCode = 0
-  process.exit = mock((code: number) => {
-    _exitCode = code
-  }) as any
+  const exitSpy = spyOn(process, 'exit').mockImplementation((code?: string | number | null) => {
+    throw new ProcessExit(code)
+  })
 
   console.log = consoleSpy
 
   try {
-    await addAction('ch123', 'msg123', 'thumbsup', { pretty: false })
+    await expect(addAction('ch123', 'msg123', 'thumbsup', { pretty: false })).rejects.toThrow(ProcessExit)
     expect(consoleSpy).toHaveBeenCalled()
     const output = JSON.parse(consoleSpy.mock.calls[0][0])
     expect(output.error).toBeDefined()
+    expect(exitSpy).toHaveBeenCalledWith(1)
   } finally {
     console.log = originalLog
-    process.exit = originalExit
+    exitSpy.mockRestore()
   }
 })

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

@@ -167,6 +167,23 @@ describe('DiscordBotClient', () => {
 
       expect(fetchCalls[0].options?.body).toBe(JSON.stringify({ content: 'Thread reply', thread_id: 'thread123' }))
     })
+
+    it('includes message_reference when reply_to is provided', async () => {
+      mockResponse({
+        id: 'msg1',
+        channel_id: 'ch1',
+        author: { id: '123', username: 'bot' },
+        content: 'Reply text',
+        timestamp: '2024-01-01T00:00:00.000Z',
+      })
+
+      const client = await new DiscordBotClient().login({ token: 'bot-token' })
+      await client.sendMessage('ch1', 'Reply text', { reply_to: 'parent123' })
+
+      expect(fetchCalls[0].options?.body).toBe(
+        JSON.stringify({ content: 'Reply text', message_reference: { message_id: 'parent123' } }),
+      )
+    })
   })
 
   describe('editMessage', () => {

package/src/platforms/discordbot/client.ts

@@ -249,11 +249,18 @@ export class DiscordBotClient {
     return this.request<DiscordChannel>('GET', `/channels/${channelId}`)
   }
 
-  async sendMessage(channelId: string, content: string, options?: { thread_id?: string }): Promise<DiscordMessage> {
-    const body: Record<string, string> = { content }
+  async sendMessage(
+    channelId: string,
+    content: string,
+    options?: { thread_id?: string; reply_to?: string },
+  ): Promise<DiscordMessage> {
+    const body: Record<string, unknown> = { content }
     if (options?.thread_id) {
       body.thread_id = options.thread_id
     }
+    if (options?.reply_to) {
+      body.message_reference = { message_id: options.reply_to }
+    }
     return this.request<DiscordMessage>('POST', `/channels/${channelId}/messages`, body)
   }
 

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

@@ -4,14 +4,15 @@ import { mkdir } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 
-const mockSendMessage = mock((_channelId: string, content: string, _options?: { thread_id?: string }) =>
-  Promise.resolve({
-    id: 'msg1',
-    channel_id: 'ch1',
-    content,
-    author: { id: 'bot1', username: 'testbot' },
-    timestamp: '2025-01-01T00:00:00.000Z',
-  }),
+const mockSendMessage = mock(
+  (_channelId: string, content: string, _options?: { thread_id?: string; reply_to?: string }) =>
+    Promise.resolve({
+      id: 'msg1',
+      channel_id: 'ch1',
+      content,
+      author: { id: 'bot1', username: 'testbot' },
+      timestamp: '2025-01-01T00:00:00.000Z',
+    }),
 )
 
 const mockGetMessages = mock((_channelId: string, _limit?: number) =>
@@ -127,7 +128,7 @@ describe('message commands', () => {
       expect(result.content).toBe('hello world')
       expect(result.author).toBe('testbot')
       expect(mockResolveChannel).toHaveBeenCalledWith('guild1', 'general')
-      expect(mockSendMessage).toHaveBeenCalledWith('ch1', 'hello world', { thread_id: undefined })
+      expect(mockSendMessage).toHaveBeenCalledWith('ch1', 'hello world', { thread_id: undefined, reply_to: undefined })
     })
 
     it('sends message to channel by ID', async () => {
@@ -135,7 +136,7 @@ describe('message commands', () => {
 
       expect(result.id).toBe('msg1')
       expect(mockResolveChannel).toHaveBeenCalledWith('guild1', '123456')
-      expect(mockSendMessage).toHaveBeenCalledWith('123456', 'hi', { thread_id: undefined })
+      expect(mockSendMessage).toHaveBeenCalledWith('123456', 'hi', { thread_id: undefined, reply_to: undefined })
     })
 
     it('sends message to thread', async () => {
@@ -145,7 +146,23 @@ describe('message commands', () => {
       })
 
       expect(result.id).toBe('msg1')
-      expect(mockSendMessage).toHaveBeenCalledWith('ch1', 'thread reply', { thread_id: 'thread123' })
+      expect(mockSendMessage).toHaveBeenCalledWith('ch1', 'thread reply', {
+        thread_id: 'thread123',
+        reply_to: undefined,
+      })
+    })
+
+    it('replies to a message', async () => {
+      const result = await sendAction('general', 'reply text', {
+        _credManager: manager,
+        reply: 'parent123',
+      })
+
+      expect(result.id).toBe('msg1')
+      expect(mockSendMessage).toHaveBeenCalledWith('ch1', 'reply text', {
+        thread_id: undefined,
+        reply_to: 'parent123',
+      })
     })
 
     it('returns error on channel not found', async () => {

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

@@ -28,7 +28,7 @@ interface MessageResult {
 export async function sendAction(
   channel: string,
   text: string,
-  options: BotOption & { thread?: string },
+  options: BotOption & { thread?: string; reply?: string },
 ): Promise<MessageResult> {
   try {
     const client = await getClient(options)
@@ -36,6 +36,7 @@ export async function sendAction(
     const channelId = await client.resolveChannel(serverId, channel)
     const message = await client.sendMessage(channelId, text, {
       thread_id: options.thread,
+      reply_to: options.reply,
     })
 
     return {
@@ -173,10 +174,11 @@ export const messageCommand = new Command('message')
       .argument('<channel>', 'Channel ID or name')
       .argument('<text>', 'Message text')
       .option('--thread <id>', 'Thread ID for replies')
+      .option('--reply <message-id>', 'Reply to a message by ID')
       .option('--bot <id>', 'Use specific bot')
       .option('--server <id>', 'Server ID')
       .option('--pretty', 'Pretty print JSON output')
-      .action(async (channel: string, text: string, opts: BotOption & { thread?: string }) => {
+      .action(async (channel: string, text: string, opts: BotOption & { thread?: string; reply?: string }) => {
         cliOutput(await sendAction(channel, text, opts), opts.pretty)
       }),
   )

package/src/platforms/instagram/commands/auth.test.ts

@@ -3,20 +3,13 @@ import { afterEach, beforeEach, describe, expect, mock, spyOn, it } from 'bun:te
 const originalConsoleLog = console.log
 import type { Command } from 'commander'
 
+import { InstagramCredentialManager } from '../credential-manager'
+
 const mockGetAccount = mock(() => Promise.resolve(null))
 const mockListAccounts = mock(() => Promise.resolve([]))
 const mockSetCurrent = mock(() => Promise.resolve(true))
 const mockRemoveAccount = mock(() => Promise.resolve(true))
 
-mock.module('../credential-manager', () => ({
-  InstagramCredentialManager: class {
-    getAccount = mockGetAccount
-    listAccounts = mockListAccounts
-    setCurrent = mockSetCurrent
-    removeAccount = mockRemoveAccount
-  },
-}))
-
 import { authCommand } from './auth'
 
 function resetCommandState(cmd: Command): void {
@@ -33,6 +26,7 @@ function resetCommandState(cmd: Command): void {
 describe('auth commands', () => {
   let consoleLogSpy: ReturnType<typeof mock>
   let processExitSpy: ReturnType<typeof spyOn>
+  const managerSpies: ReturnType<typeof spyOn>[] = []
 
   beforeEach(() => {
     resetCommandState(authCommand)
@@ -42,6 +36,13 @@ describe('auth commands', () => {
     mockSetCurrent.mockReset()
     mockRemoveAccount.mockReset()
 
+    managerSpies.push(
+      spyOn(InstagramCredentialManager.prototype, 'getAccount').mockImplementation(mockGetAccount),
+      spyOn(InstagramCredentialManager.prototype, 'listAccounts').mockImplementation(mockListAccounts),
+      spyOn(InstagramCredentialManager.prototype, 'setCurrent').mockImplementation(mockSetCurrent),
+      spyOn(InstagramCredentialManager.prototype, 'removeAccount').mockImplementation(mockRemoveAccount),
+    )
+
     consoleLogSpy = mock((..._args: unknown[]) => {})
     console.log = consoleLogSpy
     processExitSpy = spyOn(process, 'exit').mockImplementation(() => {
@@ -51,6 +52,7 @@ describe('auth commands', () => {
 
   afterEach(() => {
     console.log = originalConsoleLog
+    for (const spy of managerSpies.splice(0)) spy.mockRestore()
     processExitSpy.mockRestore()
   })
 

package/src/platforms/instagram/commands/auth.ts

@@ -6,6 +6,7 @@ import { Command } from 'commander'
 
 import { collectBrowserProfileOption } from '@/shared/chromium'
 import { handleError } from '@/shared/utils/error-handler'
+import { isInteractive } from '@/shared/utils/interactive'
 import { formatOutput } from '@/shared/utils/output'
 import { info, warn, error as stderrError, debug } from '@/shared/utils/stderr'
 
@@ -14,10 +15,6 @@ import { InstagramCredentialManager } from '../credential-manager'
 import { InstagramTokenExtractor } from '../token-extractor'
 import { createAccountId } from '../types'
 
-function isInteractive(): boolean {
-  return Boolean(process.stdin.isTTY && process.stdout.isTTY)
-}
-
 async function promptText(message: string): Promise<string | undefined> {
   const { createInterface } = await import('node:readline/promises')
   const rl = createInterface({ input: process.stdin, output: process.stdout, terminal: true })

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

@@ -3,6 +3,9 @@ import { afterEach, beforeEach, describe, expect, mock, spyOn, it } from 'bun:te
 const originalConsoleLog = console.log
 import type { Command } from 'commander'
 
+import { InstagramClient } from '../client'
+import * as sharedModule from './shared'
+
 const mockListChats = mock(() =>
   Promise.resolve([
     { id: 'thread-1', title: 'Alice', last_message: 'Hi' },
@@ -17,12 +20,6 @@ const mockClient = {
   searchChats: mockSearchChats,
 }
 
-mock.module('./shared', () => ({
-  withInstagramClient: async (_options: unknown, fn: (client: typeof mockClient) => Promise<unknown>) => {
-    return fn(mockClient)
-  },
-}))
-
 import { chatCommand } from './chat'
 
 function resetCommandState(cmd: Command): void {
@@ -39,6 +36,7 @@ function resetCommandState(cmd: Command): void {
 describe('chat commands', () => {
   let consoleLogSpy: ReturnType<typeof mock>
   let processExitSpy: ReturnType<typeof spyOn>
+  let withInstagramClientSpy: ReturnType<typeof spyOn>
 
   beforeEach(() => {
     resetCommandState(chatCommand)
@@ -56,6 +54,9 @@ describe('chat commands', () => {
 
     consoleLogSpy = mock((..._args: unknown[]) => {})
     console.log = consoleLogSpy
+    withInstagramClientSpy = spyOn(sharedModule, 'withInstagramClient').mockImplementation(async (_options, fn) => {
+      return fn(Object.assign(Object.create(InstagramClient.prototype), mockClient) as InstagramClient)
+    })
     processExitSpy = spyOn(process, 'exit').mockImplementation(() => {
       throw new Error('process.exit called')
     })
@@ -63,6 +64,7 @@ describe('chat commands', () => {
 
   afterEach(() => {
     console.log = originalConsoleLog
+    withInstagramClientSpy.mockRestore()
     processExitSpy.mockRestore()
   })
 

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

@@ -3,6 +3,9 @@ import { afterEach, beforeEach, describe, expect, mock, spyOn, it } from 'bun:te
 const originalConsoleLog = console.log
 import type { Command } from 'commander'
 
+import { InstagramClient } from '../client'
+import * as sharedModule from './shared'
+
 const mockGetMessages = mock(() => Promise.resolve([{ id: 'msg-1', text: 'Hello' }]))
 const mockSendMessage = mock(() => Promise.resolve({ id: 'msg-2', text: 'Sent' }))
 const mockSendMessageToUser = mock(() => Promise.resolve({ id: 'msg-3', text: 'Sent to user' }))
@@ -17,12 +20,6 @@ const mockClient = {
   searchUsers: mockSearchUsers,
 }
 
-mock.module('./shared', () => ({
-  withInstagramClient: async (_options: unknown, fn: (client: typeof mockClient) => Promise<unknown>) => {
-    return fn(mockClient)
-  },
-}))
-
 import { messageCommand } from './message'
 
 function resetCommandState(cmd: Command): void {
@@ -39,6 +36,7 @@ function resetCommandState(cmd: Command): void {
 describe('message commands', () => {
   let consoleLogSpy: ReturnType<typeof mock>
   let processExitSpy: ReturnType<typeof spyOn>
+  let withInstagramClientSpy: ReturnType<typeof spyOn>
 
   beforeEach(() => {
     resetCommandState(messageCommand)
@@ -57,6 +55,9 @@ describe('message commands', () => {
 
     consoleLogSpy = mock((..._args: unknown[]) => {})
     console.log = consoleLogSpy
+    withInstagramClientSpy = spyOn(sharedModule, 'withInstagramClient').mockImplementation(async (_options, fn) => {
+      return fn(Object.assign(Object.create(InstagramClient.prototype), mockClient) as InstagramClient)
+    })
     processExitSpy = spyOn(process, 'exit').mockImplementation(() => {
       throw new Error('process.exit called')
     })
@@ -64,6 +65,7 @@ describe('message commands', () => {
 
   afterEach(() => {
     console.log = originalConsoleLog
+    withInstagramClientSpy.mockRestore()
     processExitSpy.mockRestore()
   })
 

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

@@ -13,6 +13,7 @@ const mockGetAllMembers = mock(() => Promise.resolve({}))
 const mockGetMembersByIds = mock(() => Promise.resolve({}))
 const mockSyncMessages = mock(() => Promise.resolve({}))
 const mockSendMessage = mock(() => Promise.resolve({}))
+const mockSendReply = mock(() => Promise.resolve({}))
 const mockMarkRead = mock(() => Promise.resolve({}))
 const mockClose = mock(() => {})
 const mockOnClose = mock((_handler: () => void) => {})
@@ -30,6 +31,7 @@ mock.module('./protocol/session', () => ({
     getMembersByIds = mockGetMembersByIds
     syncMessages = mockSyncMessages
     sendMessage = mockSendMessage
+    sendReply = mockSendReply
     markRead = mockMarkRead
     close = mockClose
     onClose = mockOnClose
@@ -52,6 +54,7 @@ function resetAllMocks() {
   mockGetMembersByIds.mockReset()
   mockSyncMessages.mockReset()
   mockSendMessage.mockReset()
+  mockSendReply.mockReset()
   mockMarkRead.mockReset()
   mockClose.mockReset()
   mockOnClose.mockReset()
@@ -972,6 +975,60 @@ describe('KakaoTalkClient', () => {
 
       client.close()
     })
+
+    it('routes to sendReply with a built reply extra when replyTo is given', async () => {
+      // given
+      mockSendReply.mockResolvedValueOnce({ statusCode: 0, body: { logId: makeLong(50), sendAt: 1700000100 } })
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+
+      // when
+      const result = await client.sendMessage('100', 'replying', {
+        replyTo: { log_id: '42', author_id: 7, message: 'original', type: 1 },
+      })
+
+      // then
+      expect(mockSendMessage).not.toHaveBeenCalled()
+      expect(mockSendReply).toHaveBeenCalledTimes(1)
+      const [, text, extra] = mockSendReply.mock.calls[0] as [unknown, string, Record<string, unknown>]
+      expect(text).toBe('replying')
+      expect(extra).toEqual({
+        attach_only: false,
+        attach_type: 1,
+        src_logId: '42',
+        src_userId: 7,
+        src_message: 'original',
+        src_type: 1,
+        src_mentions: [],
+        mentions: [],
+      })
+      expect(result).toEqual({
+        success: true,
+        status_code: 0,
+        chat_id: '100',
+        log_id: '50',
+        sent_at: 1700000100,
+      })
+
+      client.close()
+    })
+
+    it('mirrors the source message type into attach_type/src_type', async () => {
+      // given
+      mockSendReply.mockResolvedValueOnce({ statusCode: 0, body: { logId: makeLong(51), sendAt: 1700000101 } })
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+
+      // when — replying to a photo (type 2)
+      await client.sendMessage('100', 'nice pic', {
+        replyTo: { log_id: '99', author_id: 3, message: 'photo', type: 2 },
+      })
+
+      // then
+      const [, , extra] = mockSendReply.mock.calls[0] as [unknown, string, Record<string, unknown>]
+      expect(extra.attach_type).toBe(2)
+      expect(extra.src_type).toBe(2)
+
+      client.close()
+    })
   })
 
   describe('markRead', () => {

package/src/platforms/kakaotalk/client.ts

@@ -23,6 +23,8 @@ import {
   type KakaoMessage,
   type KakaoMultiPhotoExtra,
   type KakaoProfile,
+  type KakaoReplyExtra,
+  type KakaoReplyTarget,
   type KakaoSendResult,
 } from './types'
 
@@ -445,6 +447,19 @@ function formatMessages(
   }))
 }
 
+function buildReplyExtra(target: KakaoReplyTarget): KakaoReplyExtra {
+  return {
+    attach_only: false,
+    attach_type: target.type,
+    src_logId: target.log_id,
+    src_userId: target.author_id,
+    src_message: target.message,
+    src_type: target.type,
+    src_mentions: [],
+    mentions: [],
+  }
+}
+
 export class KakaoTalkClient {
   private oauthToken: string | null = null
   private userId: string | null = null
@@ -883,10 +898,16 @@ export class KakaoTalkClient {
     })
   }
 
-  async sendMessage(chatId: string, text: string): Promise<KakaoSendResult> {
+  async sendMessage(chatId: string, text: string, options?: { replyTo?: KakaoReplyTarget }): Promise<KakaoSendResult> {
     return this.executeWithReconnect(async ({ session }) => {
       try {
-        const response = await session.sendMessage(parseLong(chatId), text)
+        const response = options?.replyTo
+          ? await session.sendReply(
+              parseLong(chatId),
+              text,
+              buildReplyExtra(options.replyTo) as unknown as Record<string, unknown>,
+            )
+          : await session.sendMessage(parseLong(chatId), text)
 
         return {
           success: response.statusCode === 0,