agent-messenger 2.35.0 → 2.36.1

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.35.0
+version: 2.36.1
 allowed-tools: Bash(agent-teams:*)
 metadata:
   openclaw:
@@ -205,6 +205,11 @@ Output includes the authenticated user's identity information.
 agent-teams message send <team-id> <channel-id> <content>
 agent-teams message send <team-id> 19:abc123@thread.tacv2 "Hello world"
 
+# Send a rich-text message written in markdown
+agent-teams message send <team-id> <channel-id> "## Deploy done
+- service A
+- service B" --format markdown
+
 # List messages
 agent-teams message list <team-id> <channel-id>
 agent-teams message list <team-id> 19:abc123@thread.tacv2 --limit 50
@@ -249,15 +254,52 @@ agent-teams chat history <chat-id> --limit 100
 
 # Send a message to a chat
 agent-teams chat send <chat-id> "Hello"
+agent-teams chat send <chat-id> "**Important**: see the [board](https://example.com)" --format markdown
 
 # Edit one of your own chat messages
 agent-teams chat edit <chat-id> <message-id> "Updated text"
+agent-teams chat edit <chat-id> <message-id> "Fixed \`bug\`" --format markdown
 ```
 
 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.
 
 `chat edit` only works on your own messages, and only for chats — Teams channel messages are not editable through this API.
 
+### Message Formatting
+
+`message send`, `chat send`, and `chat edit` accept `--format <text|markdown|html>` (default `text`).
+
+In `text` mode the content is HTML-escaped, so `<`, `>`, and `&` are sent literally.
+
+In `markdown` mode the content is converted to HTML before sending. Supported syntax:
+
+| Syntax | Renders as |
+| --- | --- |
+| `# Heading` through `#### Heading` | headings |
+| `##### Heading`, `###### Heading` | **not supported** — indistinguishable from body text |
+| `**bold**`, `_italic_`, `***bold italic***` | emphasis |
+| `` `inline code` `` | inline code |
+| triple-backtick fence | fenced code block, without syntax highlighting |
+| `- item` | bulleted list |
+| `1. item` | numbered list |
+| `> quote` | blockquote |
+| `[label](https://example.com)` | link |
+| `---` | horizontal rule |
+
+Heading levels 5 and 6 are unusable: the Teams client renders `<h5>` and `<h6>` at body size, so they are indistinguishable from surrounding text. Only go as deep as `####`. Fenced code blocks render as monospaced blocks but are never syntax-highlighted — a language tag (` ```ts `) is accepted and then ignored. Both behaviors were verified against a live account.
+
+Links are restricted to `http:`, `https:`, `mailto:`, root-relative (`/`), and anchor (`#`) URLs; anything else renders as plain text.
+
+In `html` mode the content is filtered through a tag whitelist rather than sent verbatim. Use it when you need Teams-specific markup that markdown cannot express — most commonly @mentions:
+
+```bash
+agent-teams message send <team-id> <channel-id> "Hey <at id=\"29:abc\">John</at>, build is ready" --format html
+```
+
+Allowed tags: `at`, `a`, `b`, `i`, `u`, `s`, `strong`, `em`, `code`, `pre`, `br`, `p`, `ul`, `ol`, `li`, `blockquote`, `h1`–`h6`, `hr`. `<at>` only keeps its `id` attribute; `<a>` only keeps `href`, and only when it matches the same URL whitelist as markdown mode; every other tag keeps no attributes at all. Anything not on the list — `<script>`, `<img>`, `on*` event attributes, malformed or unrecognized tags — is escaped or stripped rather than passed through.
+
+The whitelist limits the blast radius, but it does not make the mode safe for arbitrary input: only pass content you construct yourself. Untrusted input belongs in `text` mode.
+
 ### Team Commands
 
 ```bash
@@ -385,7 +427,7 @@ agent-teams channel list --pretty
 | Channel identifiers | UUID format (19:xxx@thread.tacv2) | Snowflake IDs  | Channel name or ID |
 | Token storage       | Cookies SQLite                    | LevelDB        | LevelDB            |
 | Token expiry        | **60-90 minutes**                 | Rarely expires | Rarely expires     |
-| Mentions            | `<at id="user-id">Name</at>`      | `<@user_id>`   | `<@USER_ID>`       |
+| Mentions            | `<at id="user-id">Name</at>` (needs `--format html`) | `<@user_id>`   | `<@USER_ID>`       |
 
 **Important**: Teams uses UUID-style channel IDs (like `19:abc123@thread.tacv2`). You cannot use channel names directly - use `channel list` to find IDs first.
 

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

@@ -279,12 +279,12 @@ if [ -z "$USER_ID" ] || [ "$USER_ID" = "null" ]; then
 fi
 
 # Send message with mention (Teams format)
-agent-teams message send "$TEAM_ID" "$CHANNEL_ID" "Hey <at id=\"$USER_ID\">$USER_NAME</at>, the build is ready for review!"
+agent-teams message send "$TEAM_ID" "$CHANNEL_ID" "Hey <at id=\"$USER_ID\">$USER_NAME</at>, the build is ready for review!" --format html
 ```
 
 **When to use**: Notifications, task assignments, code review requests.
 
-**Note**: Teams mentions use format `<at id="USER_ID">Display Name</at>`.
+**Note**: Teams mentions use format `<at id="USER_ID">Display Name</at>` and require `--format html` — in the default `text` mode the tags are escaped and render literally.
 
 ## Pattern 8: Reaction-Based Workflow
 

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

package/skills/agent-webexbot/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: agent-webexbot
 description: Interact with Cisco Webex using bot tokens - send messages, reply in threads, upload and download files, look up people, read spaces, manage memberships, stream real-time events
-version: 2.35.0
+version: 2.36.1
 allowed-tools: Bash(agent-webexbot:*)
 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.35.0
+version: 2.36.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.35.0
+version: 2.36.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.35.0
+version: 2.36.1
 allowed-tools: Bash(agent-whatsappbot:*)
 metadata:
   openclaw:

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

@@ -328,6 +328,38 @@ describe('TeamsClient', () => {
         }),
       )
     })
+
+    it('converts markdown to HTML when format is markdown', async () => {
+      mockResponse({ OriginalArrivalTime: 1704067200000 })
+
+      const client = await new TeamsClient().login({ token: 'test-token', accountType: 'personal' })
+      const message = await client.sendChatMessage('19:1on1@unq.gbl.spaces', '**bold** and `code`', 'markdown')
+
+      // The return value echoes the caller's original markdown, not the converted HTML
+      expect(message.content).toBe('**bold** and `code`')
+      expect(fetchCalls[0].options?.body).toBe(
+        JSON.stringify({
+          content: '<strong>bold</strong> and <code>code</code>',
+          messagetype: 'RichText/Html',
+          contenttype: 'text',
+        }),
+      )
+    })
+
+    it('passes content through unchanged when format is html', async () => {
+      mockResponse({ OriginalArrivalTime: 1704067200000 })
+
+      const client = await new TeamsClient().login({ token: 'test-token', accountType: 'personal' })
+      await client.sendChatMessage('19:1on1@unq.gbl.spaces', '<b>raw</b>', 'html')
+
+      expect(fetchCalls[0].options?.body).toBe(
+        JSON.stringify({
+          content: '<b>raw</b>',
+          messagetype: 'RichText/Html',
+          contenttype: 'text',
+        }),
+      )
+    })
   })
 
   describe('editChatMessage', () => {
@@ -352,6 +384,39 @@ describe('TeamsClient', () => {
         }),
       )
     })
+
+    it('converts markdown to HTML when format is markdown', 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', '**bold**', 'markdown')
+
+      expect(message.content).toBe('**bold**')
+      expect(fetchCalls[0].options?.body).toBe(
+        JSON.stringify({
+          content: '<strong>bold</strong>',
+          messagetype: 'RichText/Html',
+          contenttype: 'text',
+          skypeeditedid: 'msg1',
+        }),
+      )
+    })
+
+    it('passes content through unchanged when format is html', async () => {
+      mockResponse({ edittime: 1704067200000 })
+
+      const client = await new TeamsClient().login({ token: 'test-token', accountType: 'personal' })
+      await client.editChatMessage('19:1on1@unq.gbl.spaces', 'msg1', '<b>raw</b>', 'html')
+
+      expect(fetchCalls[0].options?.body).toBe(
+        JSON.stringify({
+          content: '<b>raw</b>',
+          messagetype: 'RichText/Html',
+          contenttype: 'text',
+          skypeeditedid: 'msg1',
+        }),
+      )
+    })
   })
 
   describe('getTeam', () => {
@@ -437,6 +502,68 @@ describe('TeamsClient', () => {
       expect(message.parent_message_id).toBe('root1')
       expect(message.is_thread_reply).toBe(true)
     })
+
+    it('escapes HTML in channel messages when format is text', async () => {
+      mockResponse({
+        id: 'msg1',
+        channel_id: 'ch1',
+        author: { id: '123', displayName: 'Test User' },
+        content: 'a &lt;b&gt; &amp; c',
+        timestamp: '2024-01-01T00:00:00.000Z',
+      })
+
+      const client = await new TeamsClient().login({ token: 'test-token', region: 'emea' })
+      await client.sendMessage('111', 'ch1', 'a <b> & c')
+
+      expect(fetchCalls[0].options?.body).toBe(JSON.stringify({ content: 'a &lt;b&gt; &amp; c' }))
+    })
+
+    it('converts markdown to HTML for channel messages', async () => {
+      mockResponse({
+        id: 'msg1',
+        channel_id: 'ch1',
+        author: { id: '123', displayName: 'Test User' },
+        content: '<strong>bold</strong>',
+        timestamp: '2024-01-01T00:00:00.000Z',
+      })
+
+      const client = await new TeamsClient().login({ token: 'test-token', region: 'emea' })
+      await client.sendMessage('111', 'ch1', '**bold**', undefined, 'markdown')
+
+      expect(fetchCalls[0].options?.body).toBe(JSON.stringify({ content: '<strong>bold</strong>' }))
+    })
+
+    it('converts markdown to HTML for channel thread replies', async () => {
+      mockResponse({
+        id: 'reply1',
+        channel_id: 'ch1',
+        author: { id: '123', displayName: 'Test User' },
+        content: '<strong>bold</strong>',
+        timestamp: '2024-01-01T00:01:00.000Z',
+      })
+
+      const client = await new TeamsClient().login({ token: 'test-token', region: 'emea' })
+      await client.sendMessage('111', 'ch1', '**bold**', 'root1', 'markdown')
+
+      expect(fetchCalls[0].options?.body).toBe(
+        JSON.stringify({ content: '<strong>bold</strong>', parentMessageId: 'root1' }),
+      )
+    })
+
+    it('passes content through unchanged when format is html', async () => {
+      mockResponse({
+        id: 'msg1',
+        channel_id: 'ch1',
+        author: { id: '123', displayName: 'Test User' },
+        content: 'Hey <at id="29:xyz">John</at>',
+        timestamp: '2024-01-01T00:00:00.000Z',
+      })
+
+      const client = await new TeamsClient().login({ token: 'test-token', region: 'emea' })
+      await client.sendMessage('111', 'ch1', 'Hey <at id="29:xyz">John</at>', undefined, 'html')
+
+      expect(fetchCalls[0].options?.body).toBe(JSON.stringify({ content: 'Hey <at id="29:xyz">John</at>' }))
+    })
   })
 
   describe('getMessages', () => {

package/src/platforms/teams/client.ts

@@ -2,8 +2,11 @@ import { randomUUID } from 'node:crypto'
 import { readFile } from 'node:fs/promises'
 import { basename } from 'node:path'
 
+import { escapeHtml, markdownToHtml } from '@/shared/utils/markdown-to-html'
+
 import { SUBSTRATE_SEARCH_URL } from './app-config'
 import { TeamsCredentialManager } from './credential-manager'
+import { sanitizeTeamsHtml } from './html-sanitizer'
 import { TeamsTokenProvider } from './token-provider'
 import type {
   TeamsAccountType,
@@ -12,6 +15,7 @@ import type {
   TeamsChatType,
   TeamsFile,
   TeamsMessage,
+  TeamsMessageFormat,
   TeamsRegion,
   TeamsSearchResult,
   TeamsTeam,
@@ -230,13 +234,9 @@ async function readDownloadResponse(response: Response, codePrefix: string): Pro
   return Buffer.from(await response.arrayBuffer())
 }
 
-function escapeHtml(value: string): string {
-  return value
-    .replaceAll('&', '&')
-    .replaceAll('<', '&lt;')
-    .replaceAll('>', '&gt;')
-    .replaceAll('"', '&quot;')
-    .replaceAll("'", '&#39;')
+function formatContent(content: string, format: TeamsMessageFormat): string {
+  if (format === 'html') return sanitizeTeamsHtml(content)
+  return format === 'markdown' ? markdownToHtml(content) : escapeHtml(content)
 }
 
 function withThreadMetadata(message: RawTeamsMessage, rootMessageId?: string): TeamsMessage {
@@ -692,13 +692,13 @@ export class TeamsClient {
       }))
   }
 
-  async sendChatMessage(chatId: string, content: string): Promise<TeamsMessage> {
+  async sendChatMessage(chatId: string, content: string, format: TeamsMessageFormat = 'text'): Promise<TeamsMessage> {
     interface SendResponse {
       OriginalArrivalTime?: number
     }
     const encodedChatId = encodeURIComponent(chatId)
     const response = await this.request<SendResponse>('POST', `/users/ME/conversations/${encodedChatId}/messages`, {
-      content: escapeHtml(content),
+      content: formatContent(content, format),
       messagetype: 'RichText/Html',
       contenttype: 'text',
     })
@@ -713,7 +713,12 @@ export class TeamsClient {
     }
   }
 
-  async editChatMessage(chatId: string, messageId: string, content: string): Promise<TeamsMessage> {
+  async editChatMessage(
+    chatId: string,
+    messageId: string,
+    content: string,
+    format: TeamsMessageFormat = 'text',
+  ): Promise<TeamsMessage> {
     interface EditResponse {
       edittime?: string | number
     }
@@ -724,7 +729,7 @@ export class TeamsClient {
       'PUT',
       `/users/ME/conversations/${encodedChatId}/messages/${encodedMessageId}`,
       {
-        content: escapeHtml(content),
+        content: formatContent(content, format),
         messagetype: 'RichText/Html',
         contenttype: 'text',
         skypeeditedid: messageId,
@@ -758,12 +763,20 @@ export class TeamsClient {
     )
   }
 
-  async sendMessage(teamId: string, channelId: string, content: string, rootMessageId?: string): Promise<TeamsMessage> {
+  async sendMessage(
+    teamId: string,
+    channelId: string,
+    content: string,
+    rootMessageId?: string,
+    format: TeamsMessageFormat = 'text',
+  ): Promise<TeamsMessage> {
+    const body = formatContent(content, format)
+
     if (rootMessageId) {
       const response = await this.request<RawTeamsMessage>(
         'POST',
         `/csa/${this.region}/api/v2/teams/${teamId}/channels/${channelId}/messages/${rootMessageId}/replies`,
-        { content, parentMessageId: rootMessageId },
+        { content: body, parentMessageId: rootMessageId },
         CSA_API_BASE,
       )
       return withThreadMetadata(response, rootMessageId)
@@ -772,7 +785,7 @@ export class TeamsClient {
     return this.request<TeamsMessage>(
       'POST',
       `/csa/${this.region}/api/v2/teams/${teamId}/channels/${channelId}/messages`,
-      { content },
+      { content: body },
       CSA_API_BASE,
     )
   }

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

@@ -107,6 +107,7 @@ it('send: returns sent message', async () => {
   expect(consoleSpy).toHaveBeenCalled()
   const output = consoleSpy.mock.calls[0][0]
   expect(output).toContain('Hello world')
+  expect(clientSendChatMessageSpy).toHaveBeenCalledWith('19:1on1@unq.gbl.spaces', 'Hello world', 'text')
 })
 
 it('edit: edits a chat message and returns updated content', async () => {
@@ -115,8 +116,76 @@ it('edit: edits a chat message and returns updated content', async () => {
 
   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(clientEditChatMessageSpy).toHaveBeenCalledWith('19:1on1@unq.gbl.spaces', 'msg_123', 'Edited content', 'text')
   expect(consoleSpy).toHaveBeenCalled()
   const output = consoleSpy.mock.calls[0][0]
   expect(output).toContain('Edited content')
 })
+
+it('send: passes markdown format to the client', async () => {
+  const consoleSpy = mock((_msg: string) => {})
+  console.log = consoleSpy
+
+  await sendAction('19:1on1@unq.gbl.spaces', '**bold**', { pretty: false, format: 'markdown' })
+
+  expect(clientSendChatMessageSpy).toHaveBeenCalledWith('19:1on1@unq.gbl.spaces', '**bold**', 'markdown')
+})
+
+it('send: defaults to text format when --format is omitted', async () => {
+  const consoleSpy = mock((_msg: string) => {})
+  console.log = consoleSpy
+
+  await sendAction('19:1on1@unq.gbl.spaces', 'plain', { pretty: false })
+
+  expect(clientSendChatMessageSpy).toHaveBeenCalledWith('19:1on1@unq.gbl.spaces', 'plain', 'text')
+})
+
+it('send: rejects an invalid format', async () => {
+  const consoleSpy = mock((_msg: string) => {})
+  console.log = consoleSpy
+  const exitSpy = spyOn(process, 'exit').mockImplementation((code?: string | number | null) => {
+    throw new Error(`exit:${code}`)
+  })
+
+  try {
+    await expect(sendAction('19:1on1@unq.gbl.spaces', 'hi', { pretty: false, format: 'invalid' })).rejects.toThrow(
+      'exit:1',
+    )
+
+    expect(consoleSpy.mock.calls[0][0]).toContain('Invalid format')
+    expect(clientSendChatMessageSpy).not.toHaveBeenCalled()
+  } finally {
+    // Restore in finally: a failing assertion above would otherwise leave
+    // process.exit mocked, so every later test would throw instead of exiting.
+    exitSpy.mockRestore()
+  }
+})
+
+it('edit: passes markdown format to the client', async () => {
+  const consoleSpy = mock((_msg: string) => {})
+  console.log = consoleSpy
+
+  await editAction('19:1on1@unq.gbl.spaces', 'msg_123', '**bold**', { pretty: false, format: 'markdown' })
+
+  expect(clientEditChatMessageSpy).toHaveBeenCalledWith('19:1on1@unq.gbl.spaces', 'msg_123', '**bold**', 'markdown')
+})
+
+it('edit: rejects an invalid format', async () => {
+  const consoleSpy = mock((_msg: string) => {})
+  console.log = consoleSpy
+  const exitSpy = spyOn(process, 'exit').mockImplementation((code?: string | number | null) => {
+    throw new Error(`exit:${code}`)
+  })
+
+  try {
+    await expect(
+      editAction('19:1on1@unq.gbl.spaces', 'msg_123', 'hi', { pretty: false, format: 'invalid' }),
+    ).rejects.toThrow('exit:1')
+
+    expect(clientEditChatMessageSpy).not.toHaveBeenCalled()
+  } finally {
+    // Restore in finally: a failing assertion above would otherwise leave
+    // process.exit mocked, so every later test would throw instead of exiting.
+    exitSpy.mockRestore()
+  }
+})

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

@@ -5,6 +5,7 @@ import { formatOutput } from '@/shared/utils/output'
 
 import { TeamsClient } from '../client'
 import { TeamsCredentialManager } from '../credential-manager'
+import { resolveFormat } from './format'
 
 export async function listAction(options: { pretty?: boolean }): Promise<void> {
   try {
@@ -70,7 +71,13 @@ export async function historyAction(chatId: string, options: { limit?: number; p
   }
 }
 
-export async function sendAction(chatId: string, content: string, options: { pretty?: boolean }): Promise<void> {
+export async function sendAction(
+  chatId: string,
+  content: string,
+  options: { pretty?: boolean; format?: string },
+): Promise<void> {
+  const format = resolveFormat(options.format, options.pretty)
+
   try {
     const credManager = new TeamsCredentialManager()
     const cred = await credManager.getTokenWithExpiry()
@@ -86,7 +93,7 @@ export async function sendAction(chatId: string, content: string, options: { pre
       accountType: cred.accountType,
       region: cred.region,
     })
-    const message = await client.sendChatMessage(chatId, content)
+    const message = await client.sendChatMessage(chatId, content, format)
 
     const output = {
       id: message.id,
@@ -104,8 +111,10 @@ export async function editAction(
   chatId: string,
   messageId: string,
   content: string,
-  options: { pretty?: boolean },
+  options: { pretty?: boolean; format?: string },
 ): Promise<void> {
+  const format = resolveFormat(options.format, options.pretty)
+
   try {
     const credManager = new TeamsCredentialManager()
     const cred = await credManager.getTokenWithExpiry()
@@ -121,7 +130,7 @@ export async function editAction(
       accountType: cred.accountType,
       region: cred.region,
     })
-    const message = await client.editChatMessage(chatId, messageId, content)
+    const message = await client.editChatMessage(chatId, messageId, content, format)
 
     const output = {
       id: message.id,
@@ -161,6 +170,7 @@ export const chatCommand = new Command('chat')
       .description('Send a message to a chat')
       .argument('<chat-id>', 'Chat ID')
       .argument('<content>', 'Message content')
+      .option('--format <format>', 'Message format: text, markdown, or html', 'text')
       .option('--pretty', 'Pretty print JSON output')
       .action(sendAction),
   )
@@ -170,6 +180,7 @@ export const chatCommand = new Command('chat')
       .argument('<chat-id>', 'Chat ID')
       .argument('<message-id>', 'Message ID')
       .argument('<content>', 'New message content')
+      .option('--format <format>', 'Message format: text, markdown, or html', 'text')
       .option('--pretty', 'Pretty print JSON output')
       .action(editAction),
   )

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

@@ -0,0 +1,12 @@
+import { formatOutput } from '@/shared/utils/output'
+
+import type { TeamsMessageFormat } from '../types'
+
+export function resolveFormat(value: string | undefined, pretty: boolean | undefined): TeamsMessageFormat {
+  const format = value ?? 'text'
+  if (format !== 'text' && format !== 'markdown' && format !== 'html') {
+    console.log(formatOutput({ error: `Invalid format: ${format}. Use "text", "markdown", or "html".` }, pretty))
+    process.exit(1)
+  }
+  return format
+}

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

@@ -207,3 +207,59 @@ it('delete: returns success', async () => {
   const output = consoleSpy.mock.calls[0][0]
   expect(output).toContain('deleted')
 })
+
+it('send: passes markdown format to the client', async () => {
+  const consoleSpy = mock((_msg: string) => {})
+  console.log = consoleSpy
+
+  await sendAction('team_123', 'ch_456', '**bold**', { pretty: false, format: 'markdown' })
+
+  expect(clientSendMessageSpy).toHaveBeenCalledWith('team_123', 'ch_456', '**bold**', undefined, 'markdown')
+})
+
+it('send: defaults to text format when --format is omitted', async () => {
+  const consoleSpy = mock((_msg: string) => {})
+  console.log = consoleSpy
+
+  await sendAction('team_123', 'ch_456', 'plain', { pretty: false })
+
+  expect(clientSendMessageSpy).toHaveBeenCalledWith('team_123', 'ch_456', 'plain', undefined, 'text')
+})
+
+it('send: rejects an invalid format', async () => {
+  const consoleSpy = mock((_msg: string) => {})
+  console.log = consoleSpy
+  const exitSpy = spyOn(process, 'exit').mockImplementation((code?: string | number | null) => {
+    throw new Error(`exit:${code}`)
+  })
+
+  try {
+    await expect(sendAction('team_123', 'ch_456', 'hi', { pretty: false, format: 'invalid' })).rejects.toThrow('exit:1')
+
+    expect(consoleSpy).toHaveBeenCalled()
+    expect(consoleSpy.mock.calls[0][0]).toContain('Invalid format')
+    expect(clientSendMessageSpy).not.toHaveBeenCalled()
+  } finally {
+    // Restore in finally: a failing assertion above would otherwise leave
+    // process.exit mocked, so every later test would throw instead of exiting.
+    exitSpy.mockRestore()
+  }
+})
+
+it('send: passes html format to the client', async () => {
+  const consoleSpy = mock((_msg: string) => {})
+  console.log = consoleSpy
+
+  await sendAction('team_123', 'ch_456', '<at id="29:x">John</at>', { pretty: false, format: 'html' })
+
+  expect(clientSendMessageSpy).toHaveBeenCalledWith('team_123', 'ch_456', '<at id="29:x">John</at>', undefined, 'html')
+})
+
+it('send: passes markdown format together with --thread', async () => {
+  const consoleSpy = mock((_msg: string) => {})
+  console.log = consoleSpy
+
+  await sendAction('team_123', 'ch_456', '**bold**', { pretty: false, thread: 'root_1', format: 'markdown' })
+
+  expect(clientSendMessageSpy).toHaveBeenCalledWith('team_123', 'ch_456', '**bold**', 'root_1', 'markdown')
+})