agent-messenger 2.29.0 → 2.29.1

package/src/platforms/teams/listener.ts

@@ -16,6 +16,8 @@ import {
   fetchTrouterInfo,
   fetchTrouterSessionId,
   isMessageLossFrame,
+  isThreadConversation,
+  parseMentions,
   parseRequestFrame,
   registerEndpoint,
   type TrouterInfo,
@@ -40,6 +42,7 @@ interface IncomingResource {
   imdisplayname?: string
   conversationLink?: string
   resourceLink?: string
+  properties?: unknown
 }
 
 export class TeamsListener {
@@ -56,6 +59,9 @@ export class TeamsListener {
   private reregisterTimer: ReturnType<typeof setInterval> | null = null
   private reconnectTimer: ReturnType<typeof setTimeout> | null = null
   private seenMessageIds = new Set<string>()
+  private channelTeamMap = new Map<string, string>()
+  private channelMapRefreshing: Promise<void> | null = null
+  private nonChannelThreads = new Set<string>()
 
   constructor(client: TeamsClient) {
     this.client = client
@@ -65,6 +71,7 @@ export class TeamsListener {
     if (this.running) return
     this.running = true
     this.reconnectAttempts = 0
+    await this.refreshChannelMap()
     await this.connect()
   }
 
@@ -214,7 +221,9 @@ export class TeamsListener {
         resource?: IncomingResource
       }
       if (decoded.resourceType === 'NewMessage' && decoded.resource) {
-        this.emitMessage(decoded.resource)
+        void this.emitMessage(decoded.resource).catch((error) => {
+          this.emitter.emit('error', error instanceof Error ? error : new Error(String(error)))
+        })
       }
       this.emitter.emit('teams_event', { resourceType: decoded.resourceType ?? 'unknown', ...decoded })
     } catch (error) {
@@ -222,18 +231,29 @@ export class TeamsListener {
     }
   }
 
-  private emitMessage(resource: IncomingResource): void {
+  private async emitMessage(resource: IncomingResource): Promise<void> {
     if (!resource.messagetype || !TEXT_MESSAGE_TYPES.has(resource.messagetype)) return
 
     const chatId = extractChatId(resource.conversationLink ?? resource.resourceLink)
     if (!chatId || !resource.id) return
+
+    // Dedup before the async classification so duplicate frames don't trigger
+    // redundant channel-map refreshes.
     if (this.seenMessageIds.has(resource.id)) return
     this.rememberMessageId(resource.id)
 
+    const classification = await this.classifyConversation(chatId)
+    if (!this.running) return
+
+    const rawContent = resource.content ?? ''
     const message: TeamsRealtimeMessage = {
       id: resource.id,
       chatId,
-      content: stripHtml(resource.content ?? ''),
+      conversationType: classification.conversationType,
+      teamId: classification.teamId,
+      channelId: classification.channelId,
+      content: stripHtml(rawContent),
+      mentions: parseMentions(resource.properties, rawContent),
       author: {
         id: extractUserId(resource.from) ?? 'unknown',
         displayName: resource.imdisplayname || extractUserId(resource.from) || 'unknown',
@@ -244,6 +264,42 @@ export class TeamsListener {
     this.emitter.emit('message', message)
   }
 
+  private async classifyConversation(
+    chatId: string,
+  ): Promise<Pick<TeamsRealtimeMessage, 'conversationType' | 'teamId' | 'channelId'>> {
+    if (!isThreadConversation(chatId)) return { conversationType: 'chat' }
+
+    let teamId = this.channelTeamMap.get(chatId)
+    // A thread we haven't cached may be a channel created/joined since start;
+    // one best-effort refresh resolves it. Group chats also look like threads
+    // but never carry a groupId, so remember the miss to avoid re-fetching
+    // /users/ME/conversations on every one of their messages.
+    if (!teamId && !this.nonChannelThreads.has(chatId)) {
+      await this.refreshChannelMap()
+      teamId = this.channelTeamMap.get(chatId)
+      if (!teamId) this.nonChannelThreads.add(chatId)
+    }
+    if (!teamId) return { conversationType: 'chat' }
+
+    return { conversationType: 'channel', teamId, channelId: chatId }
+  }
+
+  private async refreshChannelMap(): Promise<void> {
+    if (this.channelMapRefreshing) return this.channelMapRefreshing
+    this.channelMapRefreshing = this.client
+      .buildChannelTeamMap()
+      .then((map) => {
+        this.channelTeamMap = map
+      })
+      .catch((error) => {
+        this.emitter.emit('error', error instanceof Error ? error : new Error(String(error)))
+      })
+      .finally(() => {
+        this.channelMapRefreshing = null
+      })
+    return this.channelMapRefreshing
+  }
+
   private rememberMessageId(id: string): void {
     this.seenMessageIds.add(id)
     if (this.seenMessageIds.size > MESSAGE_CACHE_LIMIT) {

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

@@ -11,6 +11,8 @@ import {
   decodeMessageBody,
   extractChatId,
   isMessageLossFrame,
+  isThreadConversation,
+  parseMentions,
   parseRequestFrame,
   type TrouterInfo,
 } from './trouter'
@@ -112,3 +114,61 @@ it('decodeMessageBody unwraps nested gp (base64) payloads', () => {
   const decoded = decodeMessageBody({}, JSON.stringify({ gp }))
   expect(decoded).toEqual({ resourceType: 'NewMessage' })
 })
+
+it('isThreadConversation flags @thread ids and rejects 1:1 conversations', () => {
+  expect(isThreadConversation('19:abc@thread.tacv2')).toBe(true)
+  expect(isThreadConversation('19:abc@thread.v2')).toBe(true)
+  expect(isThreadConversation('19:uni01_abc@unq.gbl.spaces')).toBe(false)
+  expect(isThreadConversation('8:orgid:user@oneToOne.skype')).toBe(false)
+})
+
+it('parseMentions prefers the authoritative properties.mentions array', () => {
+  const properties = {
+    mentions: [
+      { itemid: '0', mri: '8:orgid:aaa', mentionType: 'person', displayName: 'Alice' },
+      { itemid: '1', mri: '8:orgid:bbb', mentionType: 'person', displayName: 'Bob' },
+    ],
+  }
+  const content =
+    '<span itemtype="http://schema.skype.com/Mention" itemscope itemid="0">Alice</span> ' +
+    '<span itemtype="http://schema.skype.com/Mention" itemscope itemid="1">Bob</span> hi'
+  expect(parseMentions(properties, content)).toEqual([
+    { id: '0', mri: '8:orgid:aaa', displayName: 'Alice' },
+    { id: '1', mri: '8:orgid:bbb', displayName: 'Bob' },
+  ])
+})
+
+it('parseMentions accepts JSON-stringified properties and mentions', () => {
+  const properties = JSON.stringify({
+    mentions: JSON.stringify([{ itemid: '0', mri: '8:orgid:aaa', displayName: 'Alice' }]),
+  })
+  expect(parseMentions(properties, '')).toEqual([{ id: '0', mri: '8:orgid:aaa', displayName: 'Alice' }])
+})
+
+it('parseMentions keeps tag mentions', () => {
+  const properties = { mentions: [{ itemid: '0', mri: 'tag:eng', mentionType: 'tag', displayName: 'Engineering' }] }
+  expect(parseMentions(properties, '')).toEqual([{ id: '0', mri: 'tag:eng', displayName: 'Engineering' }])
+})
+
+it('parseMentions falls back to content spans when properties are absent', () => {
+  const content =
+    '<readonly class="skipProofing" itemtype="http://schema.skype.com/Mention" contenteditable="false">' +
+    '<span itemtype="http://schema.skype.com/Mention" itemscope itemid="0">Alice</span></readonly> hi'
+  expect(parseMentions(undefined, content)).toEqual([{ id: '0', displayName: 'Alice' }])
+})
+
+it('parseMentions skips property entries missing itemid', () => {
+  const properties = {
+    mentions: [
+      { mri: '8:orgid:aaa', displayName: 'Alice' },
+      { itemid: '1', displayName: 'Bob' },
+    ],
+  }
+  expect(parseMentions(properties, '')).toEqual([{ id: '1', mri: undefined, displayName: 'Bob' }])
+})
+
+it('parseMentions returns an empty array for malformed data', () => {
+  expect(parseMentions('not-json', '')).toEqual([])
+  expect(parseMentions({ mentions: 'not-json' }, '')).toEqual([])
+  expect(parseMentions(null, 'plain text with no mentions')).toEqual([])
+})

package/src/platforms/teams/trouter.ts

@@ -226,3 +226,98 @@ export function extractChatId(link: string | undefined): string | null {
   const match = link.match(/conversations\/([^/]+)/)
   return match ? decodeURIComponent(match[1]) : null
 }
+
+// `id` is Teams' positional mention index (the content span's `itemid`); `mri`
+// is the target's Skype MRI, present only via `properties.mentions` metadata.
+export interface TrouterMention {
+  id: string
+  mri?: string
+  displayName: string
+}
+
+// 1:1 chats resolve to a unique roster / one-to-one conversation id; anything on
+// a thread (group chat OR team channel) shares the @thread.* family. The thread
+// family alone cannot tell a group chat from a channel — that needs the
+// conversation's groupId, which the realtime resource does not carry.
+export function isThreadConversation(conversationId: string): boolean {
+  return conversationId.includes('@thread.tacv2') || conversationId.includes('@thread.v2')
+}
+
+function parseJsonRecord(value: unknown): Record<string, unknown> | undefined {
+  const source = typeof value === 'string' ? safeJsonParse(value) : value
+  if (typeof source !== 'object' || source === null || Array.isArray(source)) return undefined
+  return source as Record<string, unknown>
+}
+
+function parseJsonArray(value: unknown): unknown[] | undefined {
+  const source = typeof value === 'string' ? safeJsonParse(value) : value
+  return Array.isArray(source) ? source : undefined
+}
+
+function safeJsonParse(value: string): unknown {
+  try {
+    return JSON.parse(value)
+  } catch {
+    return undefined
+  }
+}
+
+// Mentions arrive two ways: the authoritative `properties.mentions` array (JSON
+// or JSON-string) carries real MRIs, while the message content only has
+// positional `<span itemtype=".../Mention" itemid="N">Name</span>` markup with
+// no MRI. Prefer the metadata; fall back to scraping the content spans so a
+// mention is still surfaced when properties are missing. Never throws — bad
+// data yields an empty list.
+export function parseMentions(properties: unknown, content: string): TrouterMention[] {
+  const fromProperties = parseMentionsFromProperties(properties)
+  if (fromProperties.length > 0) return fromProperties
+  return parseMentionsFromContent(content)
+}
+
+function parseMentionsFromProperties(properties: unknown): TrouterMention[] {
+  const record = parseJsonRecord(properties)
+  if (!record) return []
+  const rawMentions = parseJsonArray(record.mentions)
+  if (!rawMentions) return []
+
+  const mentions: TrouterMention[] = []
+  for (const entry of rawMentions) {
+    if (typeof entry !== 'object' || entry === null) continue
+    const item = entry as Record<string, unknown>
+    const id = item.itemid
+    if (typeof id !== 'string' && typeof id !== 'number') continue
+    mentions.push({
+      id: String(id),
+      mri: typeof item.mri === 'string' ? item.mri : undefined,
+      displayName: typeof item.displayName === 'string' ? item.displayName : '',
+    })
+  }
+  return mentions
+}
+
+const MENTION_SPAN_REGEX = /<span\b[^>]*itemtype=["'][^"']*Mention[^"']*["'][^>]*>(.*?)<\/span>/gi
+
+function parseMentionsFromContent(content: string): TrouterMention[] {
+  const mentions: TrouterMention[] = []
+  for (const match of content.matchAll(MENTION_SPAN_REGEX)) {
+    const attributes = match[0]
+    const itemId = attributes.match(/itemid=["']([^"']*)["']/i)?.[1]
+    if (itemId === undefined) continue
+    mentions.push({
+      id: itemId,
+      displayName: stripTags(match[1]),
+    })
+  }
+  return mentions
+}
+
+function stripTags(html: string): string {
+  return html
+    .replace(/<[^>]*>/g, '')
+    .replace(/&amp;/g, '&')
+    .replace(/&lt;/g, '<')
+    .replace(/&gt;/g, '>')
+    .replace(/&quot;/g, '"')
+    .replace(/&#39;/g, "'")
+    .trim()
+}

package/src/platforms/teams/types.ts

@@ -252,10 +252,20 @@ export const TeamsConfigLegacySchema = z.object({
   ),
 })
 
+export interface TeamsMention {
+  id: string
+  mri?: string
+  displayName: string
+}
+
 export interface TeamsRealtimeMessage {
   id: string
   chatId: string
+  conversationType: 'chat' | 'channel'
+  teamId?: string
+  channelId?: string
   content: string
+  mentions: TeamsMention[]
   author: {
     id: string
     displayName: string