agent-messenger 2.19.5 → 2.20.1

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

@@ -71,12 +71,15 @@ MESSAGES=$(agent-line message list "$CHAT_ID" -n 50)
 MSG_COUNT=$(echo "$MESSAGES" | jq 'length')
 echo "Found $MSG_COUNT messages"
 
-# Show messages; encrypted Letter Sealing messages may include decryption_error.
-echo "$MESSAGES" | jq -r '.[] | "\(.author_id): \(.text // .decryption_error.message // "[non-text]")"'
+# Show messages by display name; Letter Sealing messages are decrypted when E2EE
+# key material is available, otherwise decryption_error explains why text is null.
+echo "$MESSAGES" | jq -r '.[] | "\(.author_name // .author_id): \(.text // .decryption_error.message // "[non-text]")"'
 ```
 
 **When to use**: Context gathering, summarizing conversations, catching up on missed messages.
 
+**E2EE note**: `message list` decrypts Letter Sealing (E2EE) messages when key material is available — restored from a prior QR/email login. When keys are missing, `text` is `null` and `decryption_error.code` is `missing_e2ee_key`; re-run `agent-line auth login` (QR) to provision keys.
+
 ## Pattern 4: Monitor for New Messages
 
 **Use case**: Watch a chat room and respond to new messages using the SDK

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.19.5
+version: 2.20.1
 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.19.5
+version: 2.20.1
 allowed-tools: Bash(agent-slackbot:*)
 metadata:
   openclaw:

package/skills/agent-teams/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: agent-teams
 description: Interact with Microsoft Teams - send messages, read channels, manage reactions
-version: 2.19.5
+version: 2.20.1
 allowed-tools: Bash(agent-teams:*)
 metadata:
   openclaw:
@@ -207,6 +207,23 @@ agent-teams channel info <team-id> 19:abc123@thread.tacv2
 agent-teams channel history <team-id> <channel-id> --limit 100
 ```
 
+### Chat Commands
+
+For personal Microsoft accounts (`@outlook.com` / `@live.com`) that have no teams or channels — only 1:1, group, and self chat threads. Work accounts can use these too for their 1:1 and group chats.
+
+```bash
+# List 1:1, group, and self chats
+agent-teams chat list
+
+# Get chat message history
+agent-teams chat history <chat-id> --limit 100
+
+# Send a message to a chat
+agent-teams chat send <chat-id> "Hello"
+```
+
+Chat IDs look like `19:guid1_guid2@unq.gbl.spaces` (1:1) or `19:guid@thread.tacv2` (group). Get them from `chat list`. The `48:notes` chat (`type: self`) is your personal "to me" notes thread.
+
 ### Team Commands
 
 ```bash
@@ -357,7 +374,7 @@ Common errors:
 
 - `Not authenticated`: No valid token (auto-extraction failed — see Troubleshooting)
 - `Token expired`: Token has expired and auto-refresh failed — see Troubleshooting
-- `No current team set`: Run `team switch <id>` first
+- `No current team set`: Run `team switch <id>` first. Personal accounts have no teams — use `chat list` / `chat history` / `chat send` instead
 - `Message not found`: Invalid message ID
 - `Channel not found`: Invalid channel ID
 - `401 Unauthorized`: Token expired and auto-refresh failed — see Troubleshooting
@@ -419,6 +436,7 @@ See the [Teams SDK documentation](https://agent-messenger.dev/docs/sdk/teams) fo
 - No real-time events / WebSocket connection
 - No voice/video channel support
 - No team management (create/delete channels, roles)
+- Personal accounts: chats only (no teams/channels); use the `chat` commands
 - No meeting support
 - No webhook support
 - Plain text messages only (no adaptive cards in v1)

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

@@ -438,6 +438,34 @@ SNAPSHOT=$(teams_cmd agent-teams snapshot)
 
 **When to use**: Any script that runs for more than a few minutes.
 
+## Pattern 12: Personal Account Chats (No Teams)
+
+**Use case**: Message from a personal Microsoft account (`@outlook.com` / `@live.com`), which has no teams or channels — only 1:1, group, and self ("to me") chats
+
+```bash
+#!/bin/bash
+
+# Personal accounts have no teams, so `team list` is empty and team/channel
+# commands fail with "No current team set". Use the `chat` commands instead.
+
+agent-teams auth extract 2>/dev/null || true
+
+# List chats (type is oneOnOne, group, or self)
+CHATS=$(agent-teams chat list)
+echo "$CHATS" | jq -r '.[] | "  \(.type): \(.id) — \(.topic // .last_message // "")"'
+
+# Pick a chat ID (here: the self "to me" notes thread)
+CHAT_ID=$(echo "$CHATS" | jq -r '.[] | select(.type=="self") | .id')
+
+# Read history and send a message
+agent-teams chat history "$CHAT_ID" --limit 20
+agent-teams chat send "$CHAT_ID" "Reminder: stand-up at 10am"
+```
+
+**When to use**: Any workflow on a personal/consumer Teams account. Get chat IDs from `chat list` — they look like `19:guid1_guid2@unq.gbl.spaces` (1:1), `19:guid@thread.tacv2` (group), or `48:notes` (self).
+
+**Note**: Work accounts also have 1:1 and group chats and can use these same `chat` commands.
+
 ## Best Practices
 
 ### 1. Always Handle Token Expiry

package/skills/agent-telegram/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: agent-telegram
 description: Interact with Telegram through TDLib - authenticate, inspect chats, and send messages
-version: 2.19.5
+version: 2.20.1
 allowed-tools: Bash(agent-telegram:*)
 ---
 

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.19.5
+version: 2.20.1
 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.19.5
+version: 2.20.1
 allowed-tools: Bash(agent-webex:*)
 metadata:
   openclaw:

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.19.5
+version: 2.20.1
 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.19.5
+version: 2.20.1
 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.19.5
+version: 2.20.1
 allowed-tools: Bash(agent-whatsappbot:*)
 metadata:
   openclaw:

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

@@ -56,9 +56,10 @@ describe('LineClient', () => {
   })
 
   describe('getMessages()', () => {
-    function clientWithTalk(talk: Record<string, unknown>): LineClient {
+    function clientWithTalk(talk: Record<string, unknown>, e2ee?: Record<string, unknown>): LineClient {
       const client = new LineClient()
-      ;(client as any).client = { base: { talk } }
+      const { profile, ...talkMethods } = talk
+      ;(client as any).client = { base: { talk: talkMethods, profile, e2ee: e2ee ?? {} } }
       return client
     }
 
@@ -106,28 +107,179 @@ describe('LineClient', () => {
       expect(result.map((m) => m.text)).toEqual(['c', 'b'])
     })
 
-    it('marks encrypted chunk messages without text as missing E2EE keys', async () => {
+    it('resolves author MIDs to display names via getContacts', async () => {
       const client = clientWithTalk({
+        profile: { mid: 'me' },
         getServerTime: async () => 1700000000000,
         getPreviousMessagesV2WithRequest: async () => [
-          {
-            id: '40',
-            from: 'u1',
-            text: null,
-            contentType: 'NONE',
-            createdTime: 1700000004000,
-            chunks: ['a', 'b'],
-            metadata: { e2eeMark: '2', e2eeVersion: '2' },
-          },
+          { id: '10', from: 'u1', text: 'hi', contentType: 'NONE', createdTime: 1700000001000 },
+          { id: '11', from: 'u2', text: 'yo', contentType: 'NONE', createdTime: 1700000002000 },
+        ],
+        getContacts: async ({ mids }: { mids: string[] }) =>
+          mids.map((mid) => ({ mid, displayName: mid === 'u1' ? 'Alice' : 'Bob' })),
+      })
+
+      const result = await client.getMessages('chat1', { count: 2 })
+      expect(result.map((m) => m.author_name)).toEqual(['Alice', 'Bob'])
+    })
+
+    it('batch-resolves unique authors in a single getContacts call', async () => {
+      let contactCalls = 0
+      const client = clientWithTalk({
+        profile: { mid: 'me' },
+        getServerTime: async () => 1700000000000,
+        getPreviousMessagesV2WithRequest: async () => [
+          { id: '10', from: 'u1', text: 'a', contentType: 'NONE', createdTime: 1700000001000 },
+          { id: '11', from: 'u1', text: 'b', contentType: 'NONE', createdTime: 1700000002000 },
+          { id: '12', from: 'u2', text: 'c', contentType: 'NONE', createdTime: 1700000003000 },
+        ],
+        getContacts: async ({ mids }: { mids: string[] }) => {
+          contactCalls++
+          expect([...mids].sort()).toEqual(['u1', 'u2'])
+          return mids.map((mid) => ({ mid, displayName: mid.toUpperCase() }))
+        },
+      })
+
+      const result = await client.getMessages('chat1', { count: 3 })
+      expect(contactCalls).toBe(1)
+      expect(result.map((m) => m.author_name)).toEqual(['U1', 'U1', 'U2'])
+    })
+
+    it('resolves the current user via getProfile since getContacts omits self', async () => {
+      const client = clientWithTalk({
+        profile: { mid: 'me' },
+        getServerTime: async () => 1700000000000,
+        getPreviousMessagesV2WithRequest: async () => [
+          { id: '10', from: 'me', text: 'mine', contentType: 'NONE', createdTime: 1700000001000 },
         ],
+        getContacts: async () => [],
+        getProfile: async () => ({ mid: 'me', displayName: 'My Name' }),
       })
 
       const result = await client.getMessages('chat1', { count: 1 })
-      expect(result[0].text).toBeNull()
-      expect(result[0].decryption_error).toEqual({
-        code: 'missing_e2ee_key',
-        message: 'LINE message is encrypted with Letter Sealing, but this session has no saved E2EE key material.',
+      expect(result[0].author_name).toBe('My Name')
+    })
+
+    it('falls back to bare author_id when name resolution fails', async () => {
+      const client = clientWithTalk({
+        profile: { mid: 'me' },
+        getServerTime: async () => 1700000000000,
+        getPreviousMessagesV2WithRequest: async () => [
+          { id: '10', from: 'u1', text: 'hi', contentType: 'NONE', createdTime: 1700000001000 },
+        ],
+        getContacts: async () => {
+          throw new Error('network down')
+        },
       })
+
+      const result = await client.getMessages('chat1', { count: 1 })
+      expect(result[0].author_name).toBeUndefined()
+      expect(result[0].author_id).toBe('u1')
+    })
+
+    it('decrypts Letter-Sealing chunk messages via decryptE2EEMessage', async () => {
+      const encrypted = {
+        id: '40',
+        from: 'u1',
+        text: null,
+        contentType: 'NONE',
+        createdTime: 1700000004000,
+        chunks: ['a', 'b'],
+        metadata: { e2eeMark: '2', e2eeVersion: '2' },
+      }
+      const client = clientWithTalk(
+        {
+          getServerTime: async () => 1700000000000,
+          getPreviousMessagesV2WithRequest: async () => [encrypted],
+        },
+        { decryptE2EEMessage: async (m: { id: string }) => ({ ...m, text: 'decrypted secret' }) },
+      )
+
+      const result = await client.getMessages('chat1', { count: 1 })
+      expect(result[0].text).toBe('decrypted secret')
+      expect(result[0].decryption_error).toBeUndefined()
+    })
+
+    it('normalizes metadata-shaped history messages to contentMetadata before decrypting', async () => {
+      let received: { contentMetadata?: unknown } | undefined
+      const client = clientWithTalk(
+        {
+          getServerTime: async () => 1700000000000,
+          getPreviousMessagesV2WithRequest: async () => [
+            {
+              id: '40',
+              from: 'u1',
+              text: null,
+              contentType: 'NONE',
+              createdTime: 1700000004000,
+              chunks: ['a', 'b'],
+              metadata: { e2eeMark: '2', e2eeVersion: '2' },
+            },
+          ],
+        },
+        {
+          decryptE2EEMessage: async (m: { contentMetadata?: unknown }) => {
+            received = m
+            // mirror the vendor decryptor: it reads contentMetadata.e2eeVersion
+            const meta = m.contentMetadata as { e2eeVersion?: string }
+            return { text: `v${meta.e2eeVersion}` }
+          },
+        },
+      )
+
+      const result = await client.getMessages('chat1', { count: 1 })
+      expect((received?.contentMetadata as { e2eeVersion?: string })?.e2eeVersion).toBe('2')
+      expect(result[0].text).toBe('v2')
+    })
+
+    it('surfaces missing_e2ee_key when decryption fails for lack of keys', async () => {
+      const client = clientWithTalk(
+        {
+          getServerTime: async () => 1700000000000,
+          getPreviousMessagesV2WithRequest: async () => [
+            {
+              id: '40',
+              from: 'u1',
+              text: null,
+              contentType: 'NONE',
+              createdTime: 1700000004000,
+              chunks: ['a', 'b'],
+              metadata: { e2eeMark: '2', e2eeVersion: '2' },
+            },
+          ],
+        },
+        {
+          decryptE2EEMessage: async () => {
+            throw new Error('NoE2EEKey: E2EE Key has not been saved')
+          },
+        },
+      )
+
+      const result = await client.getMessages('chat1', { count: 1 })
+      expect(result[0].text).toBeNull()
+      expect(result[0].decryption_error?.code).toBe('missing_e2ee_key')
+    })
+
+    it('does not decrypt plain messages that already carry text', async () => {
+      let decryptCalls = 0
+      const client = clientWithTalk(
+        {
+          getServerTime: async () => 1700000000000,
+          getPreviousMessagesV2WithRequest: async () => [
+            { id: '50', from: 'u1', text: 'plain hello', contentType: 'NONE', createdTime: 1700000005000 },
+          ],
+        },
+        {
+          decryptE2EEMessage: async () => {
+            decryptCalls++
+            return { text: 'should-not-run' }
+          },
+        },
+      )
+
+      const result = await client.getMessages('chat1', { count: 1 })
+      expect(result[0].text).toBe('plain hello')
+      expect(decryptCalls).toBe(0)
     })
   })
 
@@ -206,8 +358,17 @@ describe('LineClient', () => {
       return out
     }
 
-    it('decrypts messages and emits event + message', async () => {
-      const op = { type: 'RECEIVE_MESSAGE', message: { id: '1', from: 'u1', to: 'me' } }
+    it('decrypts Letter-Sealing chunk messages and emits event + message', async () => {
+      const op = {
+        type: 'RECEIVE_MESSAGE',
+        message: {
+          id: '1',
+          from: 'u1',
+          to: 'me',
+          chunks: ['a', 'b'],
+          contentMetadata: { e2eeMark: '2', e2eeVersion: '2' },
+        },
+      }
       const client = clientWithStream([op], async () => ({ id: '1', from: 'u1', to: 'me', text: 'hello' }))
 
       const events = await collect(client)
@@ -216,9 +377,48 @@ describe('LineClient', () => {
       expect(msg.message.text).toBe('hello')
     })
 
+    it('normalizes metadata-only E2EE messages to contentMetadata before decrypting', async () => {
+      // given: an encrypted message whose E2EE metadata lives under `metadata`
+      // (not `contentMetadata`); the vendor decryptor reads contentMetadata
+      // unconditionally, so it must be normalized first — same as the history path
+      const op = {
+        type: 'RECEIVE_MESSAGE',
+        message: { id: '1', from: 'u1', to: 'me', chunks: ['a', 'b'], metadata: { e2eeMark: '2', e2eeVersion: '2' } },
+      }
+      const client = clientWithStream([op], async (m) => {
+        const meta = (m as { contentMetadata?: { e2eeVersion?: string } }).contentMetadata
+        return { id: '1', from: 'u1', to: 'me', text: `v${meta?.e2eeVersion}` }
+      })
+
+      const events = await collect(client)
+      const msg = events[1] as Extract<LineRawEvent, { kind: 'message' }>
+      expect(msg.message.text).toBe('v2')
+      expect(msg.message.decryption_error).toBeUndefined()
+    })
+
+    it('keeps a plain message text without decrypting it', async () => {
+      // given: a plain (non-Letter-Sealing) message that already carries text and
+      // has no E2EE chunks — decrypt MUST NOT run, mirroring the history path
+      const op = { type: 'RECEIVE_MESSAGE', message: { id: '1', from: 'u1', to: 'me', text: 'plain hi' } }
+      let decryptCalls = 0
+      const client = clientWithStream([op], async (m) => {
+        decryptCalls++
+        return m
+      })
+
+      const events = await collect(client)
+      const msg = events[1] as Extract<LineRawEvent, { kind: 'message' }>
+      expect(decryptCalls).toBe(0)
+      expect(msg.message.text).toBe('plain hi')
+      expect(msg.message.decryption_error).toBeUndefined()
+    })
+
     it('keeps streaming when E2EE decryption fails (no reconnect loop)', async () => {
       const ops = [
-        { type: 'RECEIVE_MESSAGE', message: { id: '1', from: 'u1', to: 'me', text: 'plain-on-raw' } },
+        {
+          type: 'RECEIVE_MESSAGE',
+          message: { id: '1', from: 'u1', to: 'me', chunks: ['a', 'b'], metadata: { e2eeMark: '2', e2eeVersion: '2' } },
+        },
         { type: 'NOTIFIED_READ_MESSAGE' },
       ]
       const client = clientWithStream(ops, async () => {
@@ -234,7 +434,10 @@ describe('LineClient', () => {
     })
 
     it('marks missing E2EE key failures explicitly', async () => {
-      const op = { type: 'RECEIVE_MESSAGE', message: { id: '1', from: 'u1', to: 'me' } }
+      const op = {
+        type: 'RECEIVE_MESSAGE',
+        message: { id: '1', from: 'u1', to: 'me', chunks: ['a', 'b'], metadata: { e2eeMark: '2', e2eeVersion: '2' } },
+      }
       const client = clientWithStream([op], async () => {
         throw new Error('NoE2EEKey: E2EE Key has not been saved')
       })