agent-messenger 2.12.1 → 2.13.0

package/scripts/kakao-loco-capture.ts

@@ -0,0 +1,466 @@
+#!/usr/bin/env bun
+/**
+ * KakaoTalk LOCO wire-format capture (diagnostic only).
+ *
+ * Issues a small, throttled set of LOCO requests against a real account and
+ * writes the BSON response bodies to a temp file for offline schema inspection.
+ * PII is redacted (user IDs hashed, profile URLs scrubbed, message content
+ * elided, member nicknames replaced) before anything is written to disk.
+ *
+ * Defaults are intentionally conservative: 3 chats max, 1500ms between LOCO
+ * calls, dry-run unless `--confirm` is passed. The goal is to avoid bursting
+ * KakaoTalk's servers from a real account during local investigation.
+ *
+ * Usage:
+ *   bun scripts/kakao-loco-capture.ts                 # Dry-run plan (no LOCO calls)
+ *   bun scripts/kakao-loco-capture.ts --confirm       # Execute with defaults
+ *   bun scripts/kakao-loco-capture.ts --chat-id 123 --confirm
+ *   bun scripts/kakao-loco-capture.ts --commands CHATINFO,CHATONROOM --confirm
+ *
+ * NOT shipped to npm consumers: this is a developer tool under scripts/, never
+ * imported by published code.
+ */
+
+import { createHash } from 'node:crypto'
+import { writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+import { Long } from 'bson'
+
+import { KakaoTalkClient } from '../src/platforms/kakaotalk/client'
+import type { LocoSession } from '../src/platforms/kakaotalk/protocol/session'
+
+const SUPPORTED_COMMANDS = ['CHATINFO', 'CHATONROOM', 'MEMBER', 'GETMEM', 'INFOLINK', 'LCHATLIST'] as const
+type Command = (typeof SUPPORTED_COMMANDS)[number]
+
+interface Args {
+  chatId: string | null
+  maxChats: number
+  delayMs: number
+  commands: Command[]
+  confirm: boolean
+  account: string | null
+}
+
+function parseArgs(argv: string[]): Args {
+  const args: Args = {
+    chatId: null,
+    maxChats: 3,
+    delayMs: 1500,
+    commands: [...SUPPORTED_COMMANDS],
+    confirm: false,
+    account: null,
+  }
+
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i]
+    if (arg === '--confirm') {
+      args.confirm = true
+      continue
+    }
+    const next = argv[i + 1]
+    if (arg === '--chat-id' && next) {
+      args.chatId = next
+      i++
+    } else if (arg === '--max-chats' && next) {
+      args.maxChats = Math.max(1, Number.parseInt(next, 10) || 1)
+      i++
+    } else if (arg === '--delay-ms' && next) {
+      args.delayMs = Math.max(0, Number.parseInt(next, 10) || 0)
+      i++
+    } else if (arg === '--commands' && next) {
+      const requested = next.split(',').map((s) => s.trim().toUpperCase())
+      const unknown = requested.filter((c) => !SUPPORTED_COMMANDS.includes(c as Command))
+      if (unknown.length > 0) {
+        throw new Error(`Unknown commands: ${unknown.join(', ')}. Supported: ${SUPPORTED_COMMANDS.join(', ')}`)
+      }
+      args.commands = requested as Command[]
+      i++
+    } else if (arg === '--account' && next) {
+      args.account = next
+      i++
+    } else if (arg === '--help' || arg === '-h') {
+      printHelp()
+      process.exit(0)
+    } else if (arg.startsWith('--')) {
+      throw new Error(`Unknown flag: ${arg}`)
+    }
+  }
+
+  return args
+}
+
+function printHelp(): void {
+  console.log(`
+kakao-loco-capture — diagnostic LOCO wire dumper (developer tool)
+
+Usage:
+  bun scripts/kakao-loco-capture.ts [options]
+
+Options:
+  --chat-id <id>      Probe only this chat (skips --max-chats limit for the chosen chat)
+  --max-chats <n>     Number of chats to probe from your login snapshot (default: 3)
+  --delay-ms <n>      Delay between LOCO calls in ms (default: 1500)
+  --commands <list>   Comma-separated subset of: ${SUPPORTED_COMMANDS.join(', ')}
+                      (default: all)
+  --account <id>      Use a specific KakaoTalk account
+  --confirm           Actually issue LOCO calls. Without this, prints the plan only.
+  --help, -h          Show this help
+
+Output: <tmpdir>/kakao-loco-capture-<timestamp>.json (PII redacted)
+`)
+}
+
+async function sleep(ms: number): Promise<void> {
+  if (ms <= 0) return
+  await new Promise((resolve) => setTimeout(resolve, ms))
+}
+
+function hashUserId(id: unknown): string {
+  if (id === null || id === undefined) return '<null>'
+  return `user_${createHash('sha256').update(String(id)).digest('hex').slice(0, 8)}`
+}
+
+function isLong(v: unknown): v is { low: number; high: number } {
+  return typeof v === 'object' && v !== null && 'low' in v && 'high' in v
+}
+
+const URL_PATTERN = /https?:\/\/[^\s"'<>]+/gi
+const USERID_KEYS = new Set(['userId', 'authorId', 'uid', 'i', 'mid', 'mids', 'memberIds', 'memberId', 'olu', 'opt'])
+const CONTENT_KEYS = new Set(['message', 'msg', 'content', 'statusMessage', 'desc', 'description'])
+// Keys whose string values are display names / nicknames. Replaced with a
+// length-tagged placeholder so wire-shape inspection stays useful while the
+// real names never reach disk.
+const NAME_KEYS = new Set(['nickName', 'name', 'fullName', 'authorName', 'author_name', 'k', 'ln'])
+
+function redactName(value: string): string {
+  return value.length > 0 ? `<name:${value.length}chars>` : '<name>'
+}
+
+function redact(value: unknown, key?: string): unknown {
+  if (value === null || value === undefined) return value
+  if (isLong(value)) {
+    if (key && USERID_KEYS.has(key)) return hashUserId(`${value.high}_${value.low}`)
+    return { __long: true, low: value.low, high: value.high }
+  }
+  if (typeof value === 'number') {
+    if (key && USERID_KEYS.has(key)) return hashUserId(value)
+    return value
+  }
+  if (typeof value === 'string') {
+    if (key && CONTENT_KEYS.has(key)) {
+      return value.length > 32 ? `<redacted:${value.length}chars>` : '<redacted>'
+    }
+    if (key && NAME_KEYS.has(key)) {
+      return redactName(value)
+    }
+    return value.replace(URL_PATTERN, '<url>')
+  }
+  if (typeof value === 'boolean') return value
+  if (Array.isArray(value)) {
+    // For NAME_KEYS that hold arrays of nicknames (notably `k`), redact each
+    // element as a name regardless of its position.
+    if (key && NAME_KEYS.has(key)) {
+      return value.map((v) => (typeof v === 'string' ? redactName(v) : redact(v, key)))
+    }
+    return value.map((v) => redact(v, key))
+  }
+  if (typeof value === 'object') {
+    const out: Record<string, unknown> = {}
+    for (const [k, v] of Object.entries(value)) {
+      out[k] = redact(v, k)
+    }
+    return out
+  }
+  return value
+}
+
+function parseLong(s: string): Long {
+  const big = BigInt(s)
+  const low = Number(big & 0xffffffffn)
+  const high = Number((big >> 32n) & 0xffffffffn)
+  return new Long(low, high)
+}
+
+function toLong(v: unknown): Long | null {
+  if (v && typeof v === 'object' && 'low' in v && 'high' in v) {
+    const { low, high } = v as { low: number; high: number }
+    return new Long(low, high)
+  }
+  if (typeof v === 'number' && Number.isFinite(v)) {
+    return Long.fromNumber(v)
+  }
+  return null
+}
+
+interface CaptureEntry {
+  command: Command
+  chatId: string
+  status: 'ok' | 'error'
+  status_code?: number
+  body?: unknown
+  error?: string
+  duration_ms: number
+}
+
+async function probe(
+  session: LocoSession,
+  command: Command,
+  chat: Record<string, unknown>,
+  delayMs: number,
+): Promise<CaptureEntry> {
+  const chatId = parseLong(String(chat.c))
+  const chatIdStr = String(chat.c)
+  const start = Date.now()
+
+  await sleep(delayMs)
+
+  try {
+    let body: Record<string, unknown>
+    let statusCode = 0
+
+    switch (command) {
+      case 'CHATINFO': {
+        const res = await session.getChannelInfo(chatId)
+        body = res.body
+        statusCode = res.statusCode
+        break
+      }
+      case 'CHATONROOM': {
+        const res = await session.getChatInfo(chatId)
+        body = res.body
+        statusCode = res.statusCode
+        break
+      }
+      case 'LCHATLIST': {
+        const res = await session.getChatList()
+        body = res.body
+        statusCode = res.statusCode
+        break
+      }
+      case 'MEMBER': {
+        const rawIds = (chat.i as Array<unknown> | undefined) ?? []
+        const sample: Long[] = []
+        for (const raw of rawIds.slice(0, 3)) {
+          const id = toLong(raw)
+          if (id) sample.push(id)
+        }
+        if (sample.length === 0) {
+          return {
+            command,
+            chatId: chatIdStr,
+            status: 'error',
+            error: 'no member ids available in chat data — skipping',
+            duration_ms: Date.now() - start,
+          }
+        }
+        const res = await session.getMembersByIds(chatId, sample)
+        body = res.body
+        statusCode = res.statusCode
+        break
+      }
+      case 'GETMEM': {
+        const res = await session.getAllMembers(chatId)
+        body = res.body
+        statusCode = res.statusCode
+        break
+      }
+      case 'INFOLINK': {
+        const linkId = toLong(chat.li)
+        if (!linkId) {
+          return {
+            command,
+            chatId: chatIdStr,
+            status: 'error',
+            error: 'not an open chat (no `li` field) — skipping',
+            duration_ms: Date.now() - start,
+          }
+        }
+        const res = await session.getOpenLinkInfo([linkId])
+        body = res.body
+        statusCode = res.statusCode
+        break
+      }
+    }
+
+    return {
+      command,
+      chatId: chatIdStr,
+      status: 'ok',
+      status_code: statusCode,
+      body: redact(body),
+      duration_ms: Date.now() - start,
+    }
+  } catch (error) {
+    return {
+      command,
+      chatId: chatIdStr,
+      status: 'error',
+      error: error instanceof Error ? error.message : String(error),
+      duration_ms: Date.now() - start,
+    }
+  }
+}
+
+function selfCheckRedact(): void {
+  // Defensive: any change that breaks redaction would silently leak PII into the
+  // capture file. Verify on every run against a known fixture before any LOCO
+  // calls happen. Fail loud if the contract changes.
+  const fixture = {
+    chatInfo: {
+      type: 'MultiChat',
+      chatMetas: [
+        { type: 3, content: 'My Group' },
+        { type: 1, content: 'Pinned message body' },
+      ],
+      displayMembers: [{ userId: 42, nickName: 'Alice', profileImageUrl: 'https://kakao.com/p/alice.jpg' }],
+    },
+    authorId: 1234567890,
+    message: 'secret hi',
+    k: ['Alice', 'Bob', 'Charlie'],
+    ln: 'My OpenChat Room',
+    name: 'Display Name',
+    fullName: 'Real Name',
+    l: { low: 999, high: 0 },
+  }
+  const out = redact(fixture) as Record<string, unknown>
+  const info = out.chatInfo as Record<string, unknown>
+  const display = (info.displayMembers as Array<Record<string, unknown>>)[0]
+  const metas = info.chatMetas as Array<Record<string, unknown>>
+
+  const failures: string[] = []
+  if (out.authorId === 1234567890) failures.push('authorId not hashed')
+  if (display.userId === 42) failures.push('displayMembers[].userId not hashed')
+  if ((display.profileImageUrl as string) !== '<url>') failures.push('profileImageUrl not scrubbed')
+  if ((display.nickName as string) === 'Alice') failures.push('displayMembers[].nickName not redacted')
+  if (out.message !== '<redacted>') failures.push('message content not redacted')
+  if (metas[0].content !== '<redacted>') failures.push('chatMetas content not redacted')
+  const memberNames = out.k as unknown[]
+  if (!Array.isArray(memberNames) || memberNames.some((n) => typeof n === 'string' && n === 'Alice')) {
+    failures.push('member name array (k) not redacted')
+  }
+  if (out.ln === 'My OpenChat Room') failures.push('open-link name (ln) not redacted')
+  if (out.name === 'Display Name') failures.push('display name not redacted')
+  if (out.fullName === 'Real Name') failures.push('fullName not redacted')
+  if (typeof out.l !== 'object' || (out.l as Record<string, unknown>).__long !== true) {
+    failures.push('non-user Long not preserved as tagged shape')
+  }
+
+  if (failures.length > 0) {
+    throw new Error(`redact() self-check failed:\n  - ${failures.join('\n  - ')}`)
+  }
+}
+
+async function main(): Promise<void> {
+  selfCheckRedact()
+
+  const args = parseArgs(process.argv.slice(2))
+
+  console.log('kakao-loco-capture — plan:')
+  console.log(`  max_chats: ${args.maxChats}`)
+  console.log(`  delay_ms:  ${args.delayMs}`)
+  console.log(`  commands:  ${args.commands.join(', ')}`)
+  console.log(`  chat_id:   ${args.chatId ?? '<from login snapshot>'}`)
+  console.log(`  account:   ${args.account ? '<set>' : '<current>'}`)
+  console.log(`  confirm:   ${args.confirm}`)
+  console.log()
+
+  if (!args.confirm) {
+    console.log('Dry run (no --confirm). Re-run with --confirm to actually issue LOCO calls.')
+    return
+  }
+
+  const client = new KakaoTalkClient()
+
+  // Signal handler: `finally` does not run on SIGINT/SIGTERM, so wire explicit
+  // cleanup. Without this, Ctrl-C during a long sleep() leaks the LOCO socket
+  // and ping timer.
+  let cleaningUp = false
+  const cleanup = (signal: string) => {
+    if (cleaningUp) return
+    cleaningUp = true
+    console.error(`\nReceived ${signal}, closing LOCO session...`)
+    try {
+      client.close()
+    } catch {}
+    process.exit(130)
+  }
+  process.on('SIGINT', () => cleanup('SIGINT'))
+  process.on('SIGTERM', () => cleanup('SIGTERM'))
+
+  await client.login(undefined, args.account ?? undefined)
+
+  try {
+    const allChats = await client.getChats()
+    if (allChats.length === 0) {
+      console.error('No chats in login snapshot. Aborting.')
+      return
+    }
+
+    const session = await client.acquireSession()
+
+    const sessionState = (
+      client as unknown as { state: { loginResult: { chatDatas?: Array<Record<string, unknown>> } } }
+    ).state
+    const chatDatas = sessionState?.loginResult?.chatDatas ?? []
+
+    let targets: Array<Record<string, unknown>>
+    if (args.chatId) {
+      const match = chatDatas.find((c) => String(c.c) === args.chatId)
+      if (!match) {
+        console.error(`chat ${args.chatId} not in login snapshot`)
+        return
+      }
+      targets = [match]
+    } else {
+      targets = chatDatas.slice(0, args.maxChats)
+    }
+
+    console.log(`Probing ${targets.length} chat(s) with ${args.commands.length} command(s) each...`)
+    console.log(`Estimated wire calls: ${targets.length * args.commands.length}`)
+    console.log(`Estimated duration: ~${Math.ceil((targets.length * args.commands.length * args.delayMs) / 1000)}s`)
+    console.log()
+
+    const entries: CaptureEntry[] = []
+
+    if (args.commands.includes('LCHATLIST')) {
+      entries.push({
+        command: 'LCHATLIST',
+        chatId: '<login_snapshot>',
+        status: 'ok',
+        body: redact({ chatDatas: chatDatas.slice(0, args.maxChats) }),
+        duration_ms: 0,
+      })
+    }
+
+    for (const chat of targets) {
+      for (const command of args.commands) {
+        if (command === 'LCHATLIST') continue
+        const result = await probe(session, command, chat, args.delayMs)
+        const tag = result.status === 'ok' ? 'ok ' : 'ERR'
+        console.log(
+          `  [${tag}] ${command.padEnd(10)} chat=${result.chatId} ${result.duration_ms}ms${result.error ? `: ${result.error}` : ''}`,
+        )
+        entries.push(result)
+      }
+    }
+
+    const outPath = join(tmpdir(), `kakao-loco-capture-${new Date().toISOString().replace(/[:.]/g, '-')}.json`)
+    const payload = {
+      captured_at: new Date().toISOString(),
+      args: { ...args, account: args.account ? '<set>' : null, chatId: args.chatId ? '<set>' : null },
+      entries,
+    }
+    writeFileSync(outPath, `${JSON.stringify(payload, null, 2)}\n`, { mode: 0o600 })
+    console.log()
+    console.log(`Wrote ${entries.length} entries to ${outPath}`)
+  } finally {
+    client.close()
+  }
+}
+
+main().catch((error) => {
+  console.error('kakao-loco-capture failed:', error instanceof Error ? error.message : error)
+  process.exit(1)
+})

package/skills/agent-channeltalk/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: agent-channeltalk
 description: Interact with Channel Talk using extracted desktop app or browser credentials - read chats, send messages, search messages, manage groups
-version: 2.12.1
+version: 2.13.0
 allowed-tools: Bash(agent-channeltalk:*)
 metadata:
   openclaw:

package/skills/agent-channeltalkbot/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: agent-channeltalkbot
 description: Interact with Channel Talk workspaces using API credentials - send messages, read chats, manage groups and bots
-version: 2.12.1
+version: 2.13.0
 allowed-tools: Bash(agent-channeltalkbot:*)
 metadata:
   openclaw:

package/skills/agent-discord/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: agent-discord
 description: Interact with Discord servers - send messages, read channels, manage reactions
-version: 2.12.1
+version: 2.13.0
 allowed-tools: Bash(agent-discord:*)
 metadata:
   openclaw:

package/skills/agent-discordbot/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: agent-discordbot
 description: Interact with Discord servers using bot tokens - send messages, read channels, manage reactions
-version: 2.12.1
+version: 2.13.0
 allowed-tools: Bash(agent-discordbot:*)
 metadata:
   openclaw:

package/skills/agent-instagram/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: agent-instagram
 description: Interact with Instagram DMs - send messages, read conversations, manage accounts
-version: 2.12.1
+version: 2.13.0
 allowed-tools: Bash(agent-instagram:*)
 metadata:
   openclaw:

package/skills/agent-kakaotalk/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: agent-kakaotalk
 description: Interact with KakaoTalk - send messages, read chats, manage conversations
-version: 2.12.1
+version: 2.13.0
 allowed-tools: Bash(agent-kakaotalk:*)
 metadata:
   openclaw:
@@ -288,15 +288,39 @@ agent-kakaotalk chat list
 agent-kakaotalk chat list --pretty
 agent-kakaotalk chat list --account <account-id>
 agent-kakaotalk chat list --account <account-id> --pretty
+
+# Resolve user-set room titles via CHATINFO (one extra LOCO call per chat;
+# slower, but matches the room name shown in the official KakaoTalk app)
+agent-kakaotalk chat list --resolve-titles
 ```
 
 Output includes:
 - `chat_id` — numeric chat room ID
 - `type` — chat type (1:1, group, open chat)
 - `display_name` — comma-separated member names
+- `title` — user-set room title (only populated with `--resolve-titles`; otherwise `null`). For open chats (`OM` / `OD`) without a user-set title, falls back to the OpenLink room name (one extra `INFOLINK` LOCO call per such chat).
 - `active_members` — number of active members
 - `unread_count` — unread message count
-- `last_message` — most recent message preview
+- `last_message` — most recent message preview, including `author_name` when the sender's nickname is known from the chat list (otherwise `null`)
+
+### Member Commands
+
+```bash
+# List all members of a chat room (uses LOCO GETMEM — one call per invocation)
+agent-kakaotalk member list <chat-id>
+agent-kakaotalk member list <chat-id> --pretty
+agent-kakaotalk member list <chat-id> --account <account-id>
+```
+
+Each member includes:
+- `user_id` — numeric user ID (string for safety)
+- `nickname` — display name in this chat (open chats may differ from the user's main Kakao nickname)
+- `profile_image_url`, `full_profile_image_url`, `original_profile_image_url`
+- `status_message`, `country_iso`
+- `user_type` — KakaoTalk's user type (100 = friend, 1000 = open profile, etc.); `null` when the server omits the field
+- `open_token`, `open_profile_link_id`, `open_permission` — open-chat-only fields (`null` for normal chats; `open_permission` is 1=OWNER, 2=NONE, 4=MANAGER, 8=BOT)
+
+> **SDK-only**: `KakaoTalkClient.getMembersByIds(chatId, userIds)` is available for the >100-member case where you already have specific user IDs to resolve (typically from a CHATONROOM `mi` array). It is intentionally not exposed via the CLI because acquiring those IDs requires a CHATONROOM call that is also SDK-only. Use `agent-kakaotalk member list` for the common case.
 
 ### Message Commands
 
@@ -322,6 +346,7 @@ Each message includes:
 - `log_id` — unique message identifier
 - `type` — message type (1 = text, 2 = photo, etc.)
 - `author_id` — sender's user ID
+- `author_name` — sender's nickname when known from the chat list (otherwise `null`; only the room's "display members" are cached)
 - `message` — message text content
 - `sent_at` — Unix timestamp (milliseconds)
 
@@ -354,10 +379,12 @@ All commands output JSON by default for AI consumption:
   "chat_id": "9876543210",
   "type": 2,
   "display_name": "Alice, Bob",
+  "title": null,
   "active_members": 3,
   "unread_count": 5,
   "last_message": {
-    "author_id": "1111111111",
+    "author_id": 1111111111,
+    "author_name": "Alice",
     "message": "Hello everyone!",
     "sent_at": 1705312200000
   }

package/skills/agent-kakaotalk/references/common-patterns.md

@@ -55,6 +55,8 @@ agent-kakaotalk message send "$TARGET_CHAT" "Hey Alice!"
 
 **When to use**: First time interacting with a chat, or when the user references a chat by name.
 
+> Note: `display_name` joins the chat's member nicknames. For the user-set room title (matching the KakaoTalk app), see [Pattern 9](#pattern-9-resolve-canonical-room-titles).
+
 ## Pattern 3: Monitor Chat for New Messages
 
 **Use case**: Watch a chat room and respond to new messages
@@ -221,7 +223,53 @@ echo "$UNREAD" | jq -r '.[] | "  \(.display_name // "Unknown") — \(.unread_cou
 
 **When to use**: Morning catch-up, checking for urgent messages, triage.
 
-## Pattern 9: Error Handling and Retry
+## Pattern 9: Resolve Canonical Room Titles
+
+**Use case**: Show user-set room names (matching the official KakaoTalk app) instead of comma-joined member nicknames
+
+By default, `chat list` returns `display_name` built from the chat's "display members" (a comma-joined nickname list — e.g. `"Alice, Bob, Charlie"`). The `--resolve-titles` flag fetches each chat's user-set title via the LOCO `CHATINFO` command and surfaces it in a separate `title` field.
+
+For open chats (`OM` / `OD`) without a user-set title, the CLI additionally consults the OpenLink record via `INFOLINK` and uses the link name as a fallback. This matches what KakaoTalk shows for open-chat rooms in the app sidebar.
+
+```bash
+#!/bin/bash
+
+# Without --resolve-titles: title is null, display_name is member nicknames
+agent-kakaotalk chat list | jq '.[0] | {chat_id, display_name, title}'
+# {
+#   "chat_id": "9876543210",
+#   "display_name": "Alice, Bob, Charlie",
+#   "title": null
+# }
+
+# With --resolve-titles: title is the user-set room name
+agent-kakaotalk chat list --resolve-titles | jq '.[0] | {chat_id, display_name, title}'
+# {
+#   "chat_id": "9876543210",
+#   "display_name": "Alice, Bob, Charlie",
+#   "title": "Project Standup"
+# }
+
+# Render the best available name (title preferred, display_name fallback)
+agent-kakaotalk chat list --resolve-titles \
+  | jq -r '.[] | "\(.chat_id): \(.title // .display_name // "Untitled")"'
+```
+
+**When to use**: User-facing chat pickers, room-name displays in summaries, anywhere you want output that matches what the user sees in the KakaoTalk app.
+
+**Cost**: One extra LOCO call per chat (CHATINFO). Open chats without a user-set title pay one additional call (INFOLINK). For large account snapshots this multiplies quickly — leave the flag off for hot paths.
+
+**SDK equivalent**:
+
+```typescript
+// Resolve titles for the whole list
+const chats = await client.getChats({ resolveTitles: true })
+
+// Single-chat lookup (returns null on error or missing title)
+const title = await client.getChatTitle('9876543210')
+```
+
+## Pattern 10: Error Handling and Retry
 
 **Use case**: Robust message sending with retries
 

package/skills/agent-line/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: agent-line
 description: Interact with LINE - send messages, read chats, manage conversations
-version: 2.12.1
+version: 2.13.0
 allowed-tools: Bash(agent-line:*)
 metadata:
   openclaw:

package/skills/agent-slack/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: agent-slack
 description: Interact with Slack workspaces - send messages, read channels, manage reactions
-version: 2.12.1
+version: 2.13.0
 allowed-tools: Bash(agent-slack:*)
 metadata:
   openclaw:

package/skills/agent-slackbot/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: agent-slackbot
 description: Interact with Slack workspaces using bot tokens - send messages, read channels, manage reactions
-version: 2.12.1
+version: 2.13.0
 allowed-tools: Bash(agent-slackbot:*)
 metadata:
   openclaw:
@@ -365,7 +365,6 @@ Credentials stored in `~/.config/agent-messenger/slackbot-credentials.json` (060
 - Bot can only edit/delete its own messages
 - Bot must be invited to private channels
 - No scheduled messages
-- Plain text messages only (no blocks/formatting)
 
 ## Troubleshooting