@zooid/transport-matrix 0.7.0

package/src/matrix-client.ts

@@ -0,0 +1,361 @@
+import { randomUUID } from 'node:crypto'
+
+export interface MatrixClientOptions {
+  homeserver: string
+  asToken: string
+  fetch?: typeof globalThis.fetch
+}
+
+export interface SendMessageInput {
+  roomId: string
+  asUserId: string
+  content: { msgtype: string; body: string; [k: string]: unknown }
+  threadRoot?: string
+}
+
+export interface SendCustomEventInput {
+  roomId: string
+  asUserId: string
+  eventType: string
+  content: Record<string, unknown>
+}
+
+export interface SetTypingInput {
+  roomId: string
+  asUserId: string
+  typing: boolean
+  /** ms — homeserver expects re-PUTs before this expires. Ignored when typing=false. */
+  timeoutMs?: number
+}
+
+export interface SetPresenceInput {
+  asUserId: string
+  presence: 'online' | 'unavailable' | 'offline'
+  statusMsg?: string
+}
+
+export class MatrixClient {
+  private readonly homeserver: string
+  private readonly asToken: string
+  private readonly fetch: typeof globalThis.fetch
+
+  constructor(opts: MatrixClientOptions) {
+    this.homeserver = opts.homeserver.replace(/\/$/, '')
+    this.asToken = opts.asToken
+    this.fetch = opts.fetch ?? globalThis.fetch
+  }
+
+  async registerBot(
+    localpart: string,
+  ): Promise<{ user_id: string; device_id: string } | undefined> {
+    const r = await this.fetch(`${this.homeserver}/_matrix/client/v3/register`, {
+      method: 'POST',
+      headers: { Authorization: `Bearer ${this.asToken}` },
+      body: JSON.stringify({ type: 'm.login.application_service', username: localpart }),
+    })
+    if (r.status === 200) return (await r.json()) as { user_id: string; device_id: string }
+    if (r.status === 400) {
+      const body = (await r.json()) as { errcode?: string }
+      if (body.errcode === 'M_USER_IN_USE') return undefined
+    }
+    throw new Error(`registerBot(${localpart}) failed: ${r.status}`)
+  }
+
+  async resolveAlias(alias: string): Promise<string | null> {
+    const r = await this.fetch(
+      `${this.homeserver}/_matrix/client/v3/directory/room/${encodeURIComponent(alias)}`,
+      { headers: { Authorization: `Bearer ${this.asToken}` } },
+    )
+    if (r.status === 404) return null
+    if (!r.ok) throw new Error(`resolveAlias(${alias}) failed: ${r.status}`)
+    const j = (await r.json()) as { room_id: string }
+    return j.room_id
+  }
+
+  async createRoom(opts: {
+    roomAliasName: string
+    invite: string[]
+    senderUserId: string
+    preset?: 'public_chat' | 'private_chat' | 'trusted_private_chat'
+    /** Optional `m.room.name`. When set, sent in the createRoom body so the
+     *  room has a display name from the moment it exists. */
+    name?: string
+  }): Promise<string> {
+    const body: Record<string, unknown> = {
+      room_alias_name: opts.roomAliasName,
+      invite: opts.invite,
+      preset: opts.preset ?? 'public_chat',
+    }
+    if (opts.name !== undefined) body.name = opts.name
+    const r = await this.fetch(
+      `${this.homeserver}/_matrix/client/v3/createRoom?user_id=${encodeURIComponent(opts.senderUserId)}`,
+      {
+        method: 'POST',
+        headers: {
+          Authorization: `Bearer ${this.asToken}`,
+          'content-type': 'application/json',
+        },
+        body: JSON.stringify(body),
+      },
+    )
+    if (!r.ok) {
+      const body = await r.text()
+      throw new Error(`createRoom(${opts.roomAliasName}) failed: ${r.status} ${body}`)
+    }
+    const j = (await r.json()) as { room_id: string }
+    return j.room_id
+  }
+
+  async createRoomRaw(opts: {
+    asUserId: string
+    body: Record<string, unknown>
+  }): Promise<string> {
+    const url = `${this.homeserver}/_matrix/client/v3/createRoom?user_id=${encodeURIComponent(opts.asUserId)}`
+    const r = await this.fetch(url, {
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${this.asToken}`,
+        'content-type': 'application/json',
+      },
+      body: JSON.stringify(opts.body),
+    })
+    if (!r.ok) throw new Error(`createRoomRaw failed: ${r.status}`)
+    const j = (await r.json()) as { room_id: string }
+    return j.room_id
+  }
+
+  async sendStateEvent(opts: {
+    roomId: string
+    asUserId: string
+    eventType: string
+    stateKey?: string
+    content: Record<string, unknown>
+  }): Promise<{ event_id: string }> {
+    const url =
+      `${this.homeserver}/_matrix/client/v3/rooms/${encodeURIComponent(opts.roomId)}` +
+      `/state/${encodeURIComponent(opts.eventType)}/${encodeURIComponent(opts.stateKey ?? '')}` +
+      `?user_id=${encodeURIComponent(opts.asUserId)}`
+    const r = await this.fetch(url, {
+      method: 'PUT',
+      headers: {
+        Authorization: `Bearer ${this.asToken}`,
+        'content-type': 'application/json',
+      },
+      body: JSON.stringify(opts.content),
+    })
+    if (!r.ok) throw new Error(`sendStateEvent ${opts.eventType} failed: ${r.status}`)
+    return (await r.json()) as { event_id: string }
+  }
+
+  async joinRoom(roomIdOrAlias: string, asUserId: string): Promise<void> {
+    const url =
+      `${this.homeserver}/_matrix/client/v3/join/${encodeURIComponent(roomIdOrAlias)}` +
+      `?user_id=${encodeURIComponent(asUserId)}`
+    const r = await this.fetch(url, {
+      method: 'POST',
+      headers: { Authorization: `Bearer ${this.asToken}` },
+      body: '{}',
+    })
+    if (!r.ok) throw new Error(`joinRoom(${roomIdOrAlias}) failed: ${r.status}`)
+  }
+
+  async sendMessage(input: SendMessageInput): Promise<{ event_id: string }> {
+    const content: Record<string, unknown> = { ...input.content }
+    if (input.threadRoot) {
+      content['m.relates_to'] = { rel_type: 'm.thread', event_id: input.threadRoot }
+    }
+    return this.sendEvent(input.roomId, input.asUserId, 'm.room.message', content)
+  }
+
+  async sendCustomEvent(input: SendCustomEventInput): Promise<{ event_id: string }> {
+    return this.sendEvent(input.roomId, input.asUserId, input.eventType, input.content)
+  }
+
+  async setTyping(input: SetTypingInput): Promise<void> {
+    const url =
+      `${this.homeserver}/_matrix/client/v3/rooms/${encodeURIComponent(input.roomId)}` +
+      `/typing/${encodeURIComponent(input.asUserId)}` +
+      `?user_id=${encodeURIComponent(input.asUserId)}`
+    const body: Record<string, unknown> = { typing: input.typing }
+    if (input.typing && input.timeoutMs !== undefined) body.timeout = input.timeoutMs
+    const r = await this.fetch(url, {
+      method: 'PUT',
+      headers: { Authorization: `Bearer ${this.asToken}` },
+      body: JSON.stringify(body),
+    })
+    if (!r.ok) throw new Error(`setTyping(${input.roomId}, ${input.asUserId}) failed: ${r.status}`)
+  }
+
+  async setDisplayName(asUserId: string, displayName: string): Promise<void> {
+    const url =
+      `${this.homeserver}/_matrix/client/v3/profile/${encodeURIComponent(asUserId)}/displayname` +
+      `?user_id=${encodeURIComponent(asUserId)}`
+    const r = await this.fetch(url, {
+      method: 'PUT',
+      headers: {
+        Authorization: `Bearer ${this.asToken}`,
+        'content-type': 'application/json',
+      },
+      body: JSON.stringify({ displayname: displayName }),
+    })
+    if (!r.ok) throw new Error(`setDisplayName(${asUserId}) failed: ${r.status}`)
+  }
+
+  async setPresence(input: SetPresenceInput): Promise<void> {
+    const url =
+      `${this.homeserver}/_matrix/client/v3/presence/${encodeURIComponent(input.asUserId)}/status` +
+      `?user_id=${encodeURIComponent(input.asUserId)}`
+    const body: Record<string, unknown> = { presence: input.presence }
+    if (input.statusMsg !== undefined) body.status_msg = input.statusMsg
+    const r = await this.fetch(url, {
+      method: 'PUT',
+      headers: { Authorization: `Bearer ${this.asToken}` },
+      body: JSON.stringify(body),
+    })
+    if (!r.ok) throw new Error(`setPresence(${input.asUserId}) failed: ${r.status}`)
+  }
+
+  /**
+   * Fetch a single event from a room. Used to recover thread-root context
+   * after a daemon restart wipes the in-memory threadStates cache.
+   */
+  async fetchEvent(
+    roomId: string,
+    eventId: string,
+    asUserId: string,
+  ): Promise<Record<string, unknown> | null> {
+    const url =
+      `${this.homeserver}/_matrix/client/v3/rooms/${encodeURIComponent(roomId)}` +
+      `/event/${encodeURIComponent(eventId)}` +
+      `?user_id=${encodeURIComponent(asUserId)}`
+    const r = await this.fetch(url, {
+      method: 'GET',
+      headers: { Authorization: `Bearer ${this.asToken}` },
+    })
+    if (r.status === 404) return null
+    if (!r.ok) throw new Error(`fetchEvent(${eventId}) failed: ${r.status}`)
+    return (await r.json()) as Record<string, unknown>
+  }
+
+  /**
+   * Fetch replies to a thread root via the relations endpoint, oldest-first.
+   * Pass `limit` and `from` for pagination; `next_batch` echoes back when
+   * there are more replies. Returns `{ chunk: [] }` when the root is unknown.
+   */
+  async fetchThreadRelations(opts: {
+    roomId: string
+    rootEventId: string
+    asUserId: string
+    limit?: number
+    from?: string
+  }): Promise<{ chunk: Array<Record<string, unknown>>; next_batch?: string }> {
+    const params = new URLSearchParams({
+      dir: 'f',
+      limit: String(opts.limit ?? 100),
+      user_id: opts.asUserId,
+    })
+    if (opts.from) params.set('from', opts.from)
+    const url =
+      `${this.homeserver}/_matrix/client/v1/rooms/${encodeURIComponent(opts.roomId)}` +
+      `/relations/${encodeURIComponent(opts.rootEventId)}/m.thread?${params.toString()}`
+    const r = await this.fetch(url, {
+      method: 'GET',
+      headers: { Authorization: `Bearer ${this.asToken}` },
+    })
+    if (r.status === 404) return { chunk: [] }
+    if (!r.ok) throw new Error(`fetchThreadRelations(${opts.rootEventId}) failed: ${r.status}`)
+    const body = (await r.json()) as {
+      chunk?: Array<Record<string, unknown>>
+      next_batch?: string
+    }
+    return { chunk: body.chunk ?? [], next_batch: body.next_batch }
+  }
+
+  /**
+   * Paginate the room timeline. Returns events newest-first (dir=b) per Matrix
+   * spec. The caller is responsible for reversing if it wants oldest-first.
+   */
+  async fetchRoomMessages(opts: {
+    roomId: string
+    asUserId: string
+    limit?: number
+    /** Opaque pagination token returned in `end` from a previous call. */
+    from?: string
+    /**
+     * Server-side RoomEventFilter. Common keys: `types` (whitelist event types),
+     * `not_types`, `not_rel_types` (e.g. `['m.thread']` to exclude thread
+     * replies). Encoded as JSON into the `filter` query param.
+     */
+    filter?: {
+      types?: string[]
+      not_types?: string[]
+      rel_types?: string[]
+      not_rel_types?: string[]
+    }
+  }): Promise<{ chunk: Array<Record<string, unknown>>; end?: string }> {
+    const params = new URLSearchParams({
+      dir: 'b',
+      limit: String(opts.limit ?? 50),
+      user_id: opts.asUserId,
+    })
+    if (opts.from) params.set('from', opts.from)
+    if (opts.filter) params.set('filter', JSON.stringify(opts.filter))
+    const url =
+      `${this.homeserver}/_matrix/client/v3/rooms/${encodeURIComponent(opts.roomId)}` +
+      `/messages?${params.toString()}`
+    const r = await this.fetch(url, {
+      method: 'GET',
+      headers: { Authorization: `Bearer ${this.asToken}` },
+    })
+    if (!r.ok) throw new Error(`fetchRoomMessages(${opts.roomId}) failed: ${r.status}`)
+    return (await r.json()) as { chunk: Array<Record<string, unknown>>; end?: string }
+  }
+
+  async getJoinedMembers(
+    roomId: string,
+    asUserId: string,
+  ): Promise<{ joined: Record<string, { display_name?: string }> }> {
+    const url =
+      `${this.homeserver}/_matrix/client/v3/rooms/${encodeURIComponent(roomId)}` +
+      `/joined_members?user_id=${encodeURIComponent(asUserId)}`
+    const r = await this.fetch(url, {
+      method: 'GET',
+      headers: { Authorization: `Bearer ${this.asToken}` },
+    })
+    if (!r.ok) throw new Error(`getJoinedMembers(${roomId}) failed: ${r.status}`)
+    return (await r.json()) as { joined: Record<string, { display_name?: string }> }
+  }
+
+  async fetchRoomName(roomId: string, asUserId: string): Promise<string | null> {
+    const url =
+      `${this.homeserver}/_matrix/client/v3/rooms/${encodeURIComponent(roomId)}` +
+      `/state/m.room.name/?user_id=${encodeURIComponent(asUserId)}`
+    const r = await this.fetch(url, {
+      method: 'GET',
+      headers: { Authorization: `Bearer ${this.asToken}` },
+    })
+    if (r.status === 404) return null
+    if (!r.ok) throw new Error(`fetchRoomName(${roomId}) failed: ${r.status}`)
+    const body = (await r.json()) as { name?: string }
+    return body.name ?? null
+  }
+
+  private async sendEvent(
+    roomId: string,
+    asUserId: string,
+    eventType: string,
+    content: Record<string, unknown>,
+  ): Promise<{ event_id: string }> {
+    const txn = randomUUID()
+    const url =
+      `${this.homeserver}/_matrix/client/v3/rooms/${encodeURIComponent(roomId)}` +
+      `/send/${eventType}/${txn}?user_id=${encodeURIComponent(asUserId)}`
+    const r = await this.fetch(url, {
+      method: 'PUT',
+      headers: { Authorization: `Bearer ${this.asToken}` },
+      body: JSON.stringify(content),
+    })
+    if (!r.ok) throw new Error(`sendEvent(${eventType}) failed: ${r.status}`)
+    return (await r.json()) as { event_id: string }
+  }
+}

package/src/mentions.test.ts

@@ -0,0 +1,90 @@
+import { describe, it, expect } from 'vitest'
+import { extractMentions, stripMention } from './mentions.js'
+
+describe('extractMentions', () => {
+  it('reads m.mentions.user_ids when present', () => {
+    const event = {
+      type: 'm.room.message',
+      content: {
+        msgtype: 'm.text',
+        body: 'Hi @architect',
+        'm.mentions': { user_ids: ['@architect:example.com'] },
+      },
+    }
+    expect(extractMentions(event)).toEqual(['@architect:example.com'])
+  })
+
+  it('falls back to parsing formatted_body anchors', () => {
+    const event = {
+      type: 'm.room.message',
+      content: {
+        msgtype: 'm.text',
+        body: 'Hi architect',
+        format: 'org.matrix.custom.html',
+        formatted_body:
+          'Hi <a href="https://matrix.to/#/@architect:example.com">architect</a>',
+      },
+    }
+    expect(extractMentions(event)).toEqual(['@architect:example.com'])
+  })
+
+  it('falls back to scanning body for raw user IDs', () => {
+    const event = {
+      type: 'm.room.message',
+      content: { msgtype: 'm.text', body: 'cc @qa:example.com please' },
+    }
+    expect(extractMentions(event)).toEqual(['@qa:example.com'])
+  })
+
+  it('returns empty when no mention is present', () => {
+    const event = {
+      type: 'm.room.message',
+      content: { msgtype: 'm.text', body: 'just chatting' },
+    }
+    expect(extractMentions(event)).toEqual([])
+  })
+
+  it('deduplicates IDs that appear in both m.mentions and the body', () => {
+    const event = {
+      type: 'm.room.message',
+      content: {
+        msgtype: 'm.text',
+        body: 'cc @qa:example.com',
+        'm.mentions': { user_ids: ['@qa:example.com'] },
+      },
+    }
+    expect(extractMentions(event)).toEqual(['@qa:example.com'])
+  })
+})
+
+describe('stripMention', () => {
+  it('removes the bot user ID and trims surrounding whitespace', () => {
+    expect(stripMention('@docs:localhost just say hi', '@docs:localhost')).toBe('just say hi')
+  })
+
+  it('removes a trailing mention', () => {
+    expect(stripMention('hey @docs:localhost', '@docs:localhost')).toBe('hey')
+  })
+
+  it('removes a mid-sentence mention without doubling spaces', () => {
+    expect(stripMention('hey @docs:localhost can you help', '@docs:localhost')).toBe(
+      'hey can you help',
+    )
+  })
+
+  it('leaves other users’ mentions untouched', () => {
+    expect(stripMention('@docs:localhost cc @qa:example.com', '@docs:localhost')).toBe(
+      'cc @qa:example.com',
+    )
+  })
+
+  it('removes every occurrence of the bot mention', () => {
+    expect(stripMention('@docs:localhost ping @docs:localhost again', '@docs:localhost')).toBe(
+      'ping again',
+    )
+  })
+
+  it('returns empty string when the body is just the mention', () => {
+    expect(stripMention('@docs:localhost', '@docs:localhost')).toBe('')
+  })
+})

package/src/mentions.ts

@@ -0,0 +1,38 @@
+export interface MaybeMessage {
+  content?: {
+    'm.mentions'?: { user_ids?: string[] }
+    body?: string
+    formatted_body?: string
+  }
+}
+
+const MATRIX_TO_RE = /https:\/\/matrix\.to\/#\/(@[^"<>\s]+)/g
+const RAW_USER_RE = /(@[A-Za-z0-9._\-=/+]+:[A-Za-z0-9.\-]+)/g
+
+export function extractMentions(event: MaybeMessage): string[] {
+  const out = new Set<string>()
+  const c = event.content ?? {}
+  for (const id of c['m.mentions']?.user_ids ?? []) out.add(id)
+  if (c.formatted_body) {
+    for (const m of c.formatted_body.matchAll(MATRIX_TO_RE)) {
+      out.add(decodeURIComponent(m[1]))
+    }
+  }
+  if (c.body && out.size === 0) {
+    for (const m of c.body.matchAll(RAW_USER_RE)) out.add(m[1])
+  }
+  return [...out]
+}
+
+/**
+ * Remove a single user-id mention from a message body. Strips the raw
+ * `@local:server` form and collapses any whitespace that the strip leaves
+ * behind. Other users' mentions are preserved verbatim so the agent can
+ * reason about them.
+ */
+export function stripMention(body: string, userId: string): string {
+  const escaped = userId.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+  // Match optional surrounding whitespace so we don't leave double spaces.
+  const re = new RegExp(`\\s*${escaped}\\s*`, 'g')
+  return body.replace(re, ' ').replace(/\s+/g, ' ').trim()
+}

package/src/registration.test.ts

@@ -0,0 +1,41 @@
+import { describe, it, expect } from 'vitest'
+import { renderRegistration, type MatrixTransportConfig } from './registration.js'
+
+const baseConfig: MatrixTransportConfig = {
+  id: 'zooid',
+  url: 'http://daemon:8080',
+  homeserver: 'https://matrix.example.com',
+  asToken: 'as-secret',
+  hsToken: 'hs-secret',
+  senderLocalpart: 'zooid',
+  userNamespace: '@.*:example.com',
+}
+
+describe('renderRegistration', () => {
+  it('emits the six required AS fields', () => {
+    const yaml = renderRegistration(baseConfig)
+    expect(yaml).toContain('id: zooid')
+    expect(yaml).toContain('url: http://daemon:8080')
+    expect(yaml).toContain('as_token: as-secret')
+    expect(yaml).toContain('hs_token: hs-secret')
+    expect(yaml).toContain('sender_localpart: zooid')
+    expect(yaml).toMatch(/namespaces:\s/)
+  })
+
+  it('marks the user namespace exclusive', () => {
+    const yaml = renderRegistration(baseConfig)
+    expect(yaml).toMatch(/users:\s*\n\s*-\s*exclusive:\s*true/)
+    expect(yaml).toContain("regex: '@.*:example.com'")
+  })
+
+  it('emits empty aliases and rooms namespaces', () => {
+    const yaml = renderRegistration(baseConfig)
+    expect(yaml).toMatch(/aliases:\s*\[\]/)
+    expect(yaml).toMatch(/rooms:\s*\[\]/)
+  })
+
+  it('disables rate limiting (AS calls bypass HS rate limits)', () => {
+    const yaml = renderRegistration(baseConfig)
+    expect(yaml).toContain('rate_limited: false')
+  })
+})

package/src/registration.ts

@@ -0,0 +1,44 @@
+import { stringify } from 'yaml'
+
+export interface MatrixTransportConfig {
+  id: string
+  url: string
+  homeserver: string
+  asToken: string
+  hsToken: string
+  senderLocalpart: string
+  /** Regex covering all bot users, e.g. `@.*:example.com` */
+  userNamespace: string
+  /**
+   * Optional regex covering aliases the AS may claim, e.g. `#.*:example.com`.
+   * Required when the AS calls `createRoom` with a `room_alias_name`.
+   */
+  aliasNamespace?: string
+  /**
+   * Whether the AS exclusively owns the user_namespace. Default true.
+   * Set false when humans share the namespace (e.g., `zooid dev` registers
+   * a predefined admin under the same `@.*:localhost` regex).
+   */
+  exclusive?: boolean
+}
+
+export function renderRegistration(c: MatrixTransportConfig): string {
+  return stringify(
+    {
+      id: c.id,
+      url: c.url,
+      as_token: c.asToken,
+      hs_token: c.hsToken,
+      sender_localpart: c.senderLocalpart,
+      rate_limited: false,
+      namespaces: {
+        users: [{ exclusive: c.exclusive ?? true, regex: c.userNamespace }],
+        aliases: c.aliasNamespace
+          ? [{ exclusive: c.exclusive ?? true, regex: c.aliasNamespace }]
+          : [],
+        rooms: [],
+      },
+    },
+    { defaultStringType: 'PLAIN', defaultKeyType: 'PLAIN', singleQuote: true },
+  )
+}

package/src/router.test.ts

@@ -0,0 +1,90 @@
+import { describe, it, expect } from 'vitest'
+import { route, type AgentBinding } from './router.js'
+
+const agents: AgentBinding[] = [
+  {
+    name: 'architect',
+    userId: '@architect:example.com',
+    rooms: ['!room1:example.com'],
+    trigger: 'mention',
+  },
+  {
+    name: 'monitor',
+    userId: '@monitor:example.com',
+    rooms: ['!alerts:example.com'],
+    trigger: 'any',
+  },
+]
+
+function msg(
+  overrides: Partial<{ room: string; sender: string; body: string; mentions: string[] }> = {},
+) {
+  return {
+    type: 'm.room.message',
+    room_id: overrides.room ?? '!room1:example.com',
+    sender: overrides.sender ?? '@alice:example.com',
+    event_id: '$evt',
+    content: {
+      msgtype: 'm.text',
+      body: overrides.body ?? 'hello',
+      ...(overrides.mentions ? { 'm.mentions': { user_ids: overrides.mentions } } : {}),
+    },
+  }
+}
+
+describe('route', () => {
+  it('matches mention-triggered agents only when their user id is mentioned', () => {
+    const matches = route(msg({ mentions: ['@architect:example.com'] }), agents)
+    expect(matches.map((m) => m.name)).toEqual(['architect'])
+  })
+
+  it('does not match mention-triggered agents on a plain message', () => {
+    const matches = route(msg(), agents)
+    expect(matches).toEqual([])
+  })
+
+  it('matches `any`-triggered agents on every message in their rooms', () => {
+    const matches = route(msg({ room: '!alerts:example.com' }), agents)
+    expect(matches.map((m) => m.name)).toEqual(['monitor'])
+  })
+
+  it('does not match an `any` agent in a room it does not belong to', () => {
+    const matches = route(msg({ room: '!room1:example.com' }), agents)
+    expect(matches.map((m) => m.name)).toEqual([])
+  })
+
+  it('skips events whose sender is the matched agent itself', () => {
+    const matches = route(
+      msg({ sender: '@architect:example.com', mentions: ['@architect:example.com'] }),
+      agents,
+    )
+    expect(matches).toEqual([])
+  })
+
+  it('returns multiple bindings when multiple agents are mentioned in the same event', () => {
+    const both: AgentBinding[] = [
+      ...agents,
+      {
+        name: 'qa',
+        userId: '@qa:example.com',
+        rooms: ['!room1:example.com'],
+        trigger: 'mention',
+      },
+    ]
+    const matches = route(
+      msg({ mentions: ['@architect:example.com', '@qa:example.com'] }),
+      both,
+    )
+    expect(matches.map((m) => m.name).sort()).toEqual(['architect', 'qa'])
+  })
+
+  it('ignores non-m.room.message events', () => {
+    const stateEvent = {
+      type: 'm.room.member',
+      room_id: '!room1:example.com',
+      sender: '@alice:example.com',
+      content: {},
+    }
+    expect(route(stateEvent as never, agents)).toEqual([])
+  })
+})