@zooid/transport-matrix 0.7.0

package/src/event-encoders.test.ts

@@ -0,0 +1,124 @@
+import { describe, it, expect } from 'vitest'
+import type {
+  ToolCallEvent,
+  ToolCallUpdateEvent,
+  PlanEvent,
+} from '@zooid/acp-client'
+import {
+  toToolCallBody,
+  toUpdateBody,
+  toPlanBody,
+} from './event-encoders.js'
+
+describe('toToolCallBody', () => {
+  it('maps required + optional fields with snake_case keys', () => {
+    const evt: ToolCallEvent = {
+      type: 'tool_call',
+      sessionId: 'sess-1',
+      toolCallId: 'tc-1',
+      title: 'Run tests',
+      kind: 'execute',
+      status: 'pending',
+    }
+    expect(toToolCallBody(evt)).toEqual({
+      session_id: 'sess-1',
+      tool_call_id: 'tc-1',
+      title: 'Run tests',
+      kind: 'execute',
+      status: 'pending',
+    })
+  })
+
+  it('omits optional fields when undefined', () => {
+    const evt: ToolCallEvent = {
+      type: 'tool_call',
+      sessionId: 'sess-1',
+      toolCallId: 'tc-1',
+      title: 'Run tests',
+    }
+    expect(toToolCallBody(evt)).toEqual({
+      session_id: 'sess-1',
+      tool_call_id: 'tc-1',
+      title: 'Run tests',
+    })
+  })
+
+  it('forwards rawInput as raw_input (snake_case) and locations', () => {
+    const evt: ToolCallEvent = {
+      type: 'tool_call',
+      sessionId: 'sess-1',
+      toolCallId: 'tc-1',
+      title: 'Read file',
+      kind: 'read',
+      rawInput: { filepath: '/abs/path/notes.md' },
+      locations: [{ path: '/abs/path/notes.md' }],
+    }
+    expect(toToolCallBody(evt)).toEqual({
+      session_id: 'sess-1',
+      tool_call_id: 'tc-1',
+      title: 'Read file',
+      kind: 'read',
+      raw_input: { filepath: '/abs/path/notes.md' },
+      locations: [{ path: '/abs/path/notes.md' }],
+    })
+  })
+
+  it('truncates long string values inside rawInput', () => {
+    const longDiff = 'a'.repeat(500)
+    const evt: ToolCallEvent = {
+      type: 'tool_call',
+      sessionId: 'sess-1',
+      toolCallId: 'tc-1',
+      title: 'Edit file',
+      kind: 'edit',
+      rawInput: { filepath: '/abs/short.md', diff: longDiff },
+    }
+    const body = toToolCallBody(evt) as { raw_input: Record<string, unknown> }
+    expect(body.raw_input.filepath).toBe('/abs/short.md')
+    expect(body.raw_input.diff).toBe('a'.repeat(250) + '… [truncated]')
+  })
+})
+
+describe('toUpdateBody', () => {
+  it('passes through status/kind/content with snake_case keys', () => {
+    const evt: ToolCallUpdateEvent = {
+      type: 'tool_call_update',
+      sessionId: 'sess-1',
+      toolCallId: 'tc-1',
+      status: 'completed',
+      content: [{ type: 'content', content: { type: 'text', text: 'done' } }] as never,
+    }
+    expect(toUpdateBody(evt)).toEqual({
+      session_id: 'sess-1',
+      tool_call_id: 'tc-1',
+      status: 'completed',
+      content: evt.content,
+    })
+  })
+
+  it('omits absent optional fields', () => {
+    const evt: ToolCallUpdateEvent = {
+      type: 'tool_call_update',
+      sessionId: 'sess-1',
+      toolCallId: 'tc-1',
+    }
+    expect(toUpdateBody(evt)).toEqual({
+      session_id: 'sess-1',
+      tool_call_id: 'tc-1',
+    })
+  })
+})
+
+describe('toPlanBody', () => {
+  it('forwards entries verbatim under session_id', () => {
+    const evt: PlanEvent = {
+      type: 'plan',
+      sessionId: 'sess-1',
+      entries: [{ content: 'step a', priority: 'high', status: 'pending' }] as never,
+    }
+    expect(toPlanBody(evt)).toEqual({
+      session_id: 'sess-1',
+      entries: evt.entries,
+    })
+  })
+})

package/src/event-encoders.ts

@@ -0,0 +1,66 @@
+import type {
+  PlanEvent,
+  ToolCallEvent,
+  ToolCallUpdateEvent,
+} from '@zooid/acp-client'
+
+/** Cap any single string in rawInput so big diffs / file contents don't bloat Matrix. */
+const RAW_INPUT_STR_MAX = 250
+
+export function toToolCallBody(evt: ToolCallEvent): Record<string, unknown> {
+  const out: Record<string, unknown> = {
+    session_id: evt.sessionId,
+    tool_call_id: evt.toolCallId,
+    title: evt.title,
+  }
+  if (evt.kind !== undefined) out.kind = evt.kind
+  if (evt.status !== undefined) out.status = evt.status
+  if (evt.rawInput !== undefined) out.raw_input = truncateStrings(evt.rawInput, RAW_INPUT_STR_MAX)
+  if (evt.locations !== undefined) out.locations = evt.locations
+  return out
+}
+
+/**
+ * Recursively truncates string values longer than `max` with a "… [truncated]"
+ * suffix. Non-string scalars and structure are preserved.
+ */
+function truncateStrings(v: unknown, max: number): unknown {
+  if (typeof v === 'string') {
+    return v.length > max ? v.slice(0, max) + '… [truncated]' : v
+  }
+  if (Array.isArray(v)) {
+    return v.map((item) => truncateStrings(item, max))
+  }
+  if (v && typeof v === 'object') {
+    const out: Record<string, unknown> = {}
+    for (const [k, val] of Object.entries(v as Record<string, unknown>)) {
+      out[k] = truncateStrings(val, max)
+    }
+    return out
+  }
+  return v
+}
+
+export function toUpdateBody(evt: ToolCallUpdateEvent): Record<string, unknown> {
+  const out: Record<string, unknown> = {
+    session_id: evt.sessionId,
+    tool_call_id: evt.toolCallId,
+  }
+  if (evt.status !== undefined) out.status = evt.status
+  if (evt.kind !== undefined) out.kind = evt.kind
+  // content[] carries display-ready output (text/diff/terminal); rawOutput is
+  // intentionally NOT serialized — it's typically large and duplicates content.
+  if (evt.content !== undefined) out.content = evt.content
+  // Some ACP agents only set rawInput on a later update (not the initial
+  // tool_call). Truncate strings and forward.
+  if (evt.rawInput !== undefined) out.raw_input = truncateStrings(evt.rawInput, RAW_INPUT_STR_MAX)
+  if (evt.locations !== undefined) out.locations = evt.locations
+  return out
+}
+
+export function toPlanBody(evt: PlanEvent): Record<string, unknown> {
+  return {
+    session_id: evt.sessionId,
+    entries: evt.entries,
+  }
+}

package/src/index.ts

@@ -0,0 +1,26 @@
+export { MatrixClient } from './matrix-client.js'
+export type { MatrixClientOptions, SendMessageInput, SendCustomEventInput } from './matrix-client.js'
+export { MatrixContextProvider } from './context-provider.js'
+export type { MatrixContextProviderOpts } from './context-provider.js'
+export { renderRegistration } from './registration.js'
+export type { MatrixTransportConfig } from './registration.js'
+export { extractMentions } from './mentions.js'
+export type { MaybeMessage } from './mentions.js'
+export { route } from './router.js'
+export type { AgentBinding, RouteMatch } from './router.js'
+export { BotPool } from './bot-pool.js'
+export { createMatrixTransport } from './transport.js'
+export type { CreateMatrixTransportOptions } from './transport.js'
+export { ensureWorkforceSpace, serverNameFromMxid } from './space-provisioner.js'
+export type { EnsureSpaceOpts } from './space-provisioner.js'
+export {
+  buildWorkforceRoster,
+  publishWorkforce,
+  startWorkforcePublisher,
+} from './workforce-publisher.js'
+export type {
+  WorkforceRoster,
+  PublishOpts,
+  PublisherHandle,
+  StartOpts as StartWorkforcePublisherOpts,
+} from './workforce-publisher.js'

package/src/markdown-to-matrix-html.test.ts

@@ -0,0 +1,102 @@
+import { describe, expect, it } from 'vitest'
+import { toMatrixHtml } from './markdown-to-matrix-html.js'
+
+describe('toMatrixHtml', () => {
+  it('returns empty string for empty input', () => {
+    expect(toMatrixHtml('')).toBe('')
+    expect(toMatrixHtml('   \n\n   ')).toBe('')
+  })
+
+  it('wraps plain prose in <p>', () => {
+    expect(toMatrixHtml('hello world')).toContain('<p>hello world</p>')
+  })
+
+  it('renders bold and italic', () => {
+    const out = toMatrixHtml('**bold** and _italic_')
+    expect(out).toContain('<strong>bold</strong>')
+    expect(out).toContain('<em>italic</em>')
+  })
+
+  it('renders inline code', () => {
+    expect(toMatrixHtml('use `foo()`')).toContain('<code>foo()</code>')
+  })
+
+  it('renders fenced code with language hint as class', () => {
+    const out = toMatrixHtml('```ts\nconst x = 1\n```')
+    expect(out).toContain('<pre>')
+    expect(out).toContain('<code class="language-ts">')
+    expect(out).toContain('const x = 1')
+  })
+
+  it('renders headings up to h6', () => {
+    expect(toMatrixHtml('# H1')).toContain('<h1>H1</h1>')
+    expect(toMatrixHtml('###### H6')).toContain('<h6>H6</h6>')
+  })
+
+  it('renders unordered and ordered lists', () => {
+    const ul = toMatrixHtml('- a\n- b')
+    expect(ul).toContain('<ul>')
+    expect(ul).toContain('<li>a</li>')
+    expect(ul).toContain('<li>b</li>')
+
+    const ol = toMatrixHtml('1. one\n2. two')
+    expect(ol).toContain('<ol>')
+    expect(ol).toContain('<li>one</li>')
+  })
+
+  it('renders GFM strikethrough as <del>', () => {
+    expect(toMatrixHtml('~~gone~~')).toContain('<del>gone</del>')
+  })
+
+  it('renders GFM tables', () => {
+    const md = `| a | b |\n|---|---|\n| 1 | 2 |`
+    const out = toMatrixHtml(md)
+    expect(out).toContain('<table>')
+    expect(out).toContain('<th>a</th>')
+    expect(out).toContain('<td>1</td>')
+  })
+
+  it('renders blockquotes', () => {
+    expect(toMatrixHtml('> quoted')).toContain('<blockquote>')
+  })
+
+  it('renders safe https links', () => {
+    const out = toMatrixHtml('[home](https://example.com)')
+    expect(out).toContain('<a href="https://example.com">home</a>')
+  })
+
+  it('strips javascript: URLs from links', () => {
+    const out = toMatrixHtml('[evil](javascript:alert(1))')
+    // sanitize-html drops the href; the anchor text is preserved
+    expect(out).not.toContain('javascript:')
+    expect(out).toContain('evil')
+  })
+
+  it('strips <script> tags entirely', () => {
+    const out = toMatrixHtml('<script>alert(1)</script>hello')
+    expect(out).not.toContain('<script')
+    expect(out).not.toContain('alert(1)')
+    expect(out).toContain('hello')
+  })
+
+  it('strips inline event handlers', () => {
+    const out = toMatrixHtml('<a href="https://x" onclick="bad()">x</a>')
+    expect(out).not.toContain('onclick')
+  })
+
+  it('strips <style> tags', () => {
+    const out = toMatrixHtml('<style>body{display:none}</style>safe')
+    expect(out).not.toContain('<style')
+    expect(out).toContain('safe')
+  })
+
+  it('preserves @user:server text passthrough for downstream mention rendering', () => {
+    // We do NOT convert mentions to anchors here — Zoon does that on render.
+    const out = toMatrixHtml('hello @alice:zoon.eco how are you')
+    expect(out).toContain('@alice:zoon.eco')
+  })
+
+  it('survives pathological input without throwing', () => {
+    expect(() => toMatrixHtml(' '.repeat(10))).not.toThrow()
+  })
+})

package/src/markdown-to-matrix-html.ts

@@ -0,0 +1,41 @@
+import { marked } from 'marked'
+import sanitizeHtml from 'sanitize-html'
+
+// Matrix-permitted HTML tags per the m.room.message spec.
+// https://spec.matrix.org/v1.11/client-server-api/#mroommessage-msgtypes
+const ALLOWED_TAGS = [
+  'del', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'blockquote', 'p', 'a',
+  'ul', 'ol', 'sup', 'sub', 'li', 'b', 'i', 'u', 'strong', 'em', 's',
+  'code', 'hr', 'br', 'div', 'table', 'thead', 'tbody', 'tr', 'th',
+  'td', 'caption', 'pre', 'span', 'img', 'details', 'summary',
+]
+
+const ALLOWED_ATTRIBUTES: Record<string, string[]> = {
+  a: ['href', 'name', 'target'],
+  img: ['width', 'height', 'alt', 'title', 'src'],
+  ol: ['start'],
+  code: ['class'],
+  span: ['data-mx-color', 'data-mx-bg-color', 'data-mx-spoiler'],
+}
+
+const ALLOWED_SCHEMES = ['https', 'http', 'ftp', 'mailto', 'magnet', 'matrix']
+
+marked.setOptions({ gfm: true, breaks: false, async: false })
+
+export function toMatrixHtml(markdown: string): string {
+  if (!markdown || !markdown.trim()) return ''
+  let rawHtml: string
+  try {
+    const out = marked.parse(markdown) as string | Promise<string>
+    if (typeof out !== 'string') return ''
+    rawHtml = out
+  } catch {
+    return ''
+  }
+  return sanitizeHtml(rawHtml, {
+    allowedTags: ALLOWED_TAGS,
+    allowedAttributes: ALLOWED_ATTRIBUTES,
+    allowedSchemes: ALLOWED_SCHEMES,
+    allowedSchemesByTag: { a: ALLOWED_SCHEMES },
+  })
+}

package/src/matrix-client.test.ts

@@ -0,0 +1,307 @@
+import { describe, it, expect, vi } from 'vitest'
+import { MatrixClient } from './matrix-client.js'
+
+function fakeFetch(handler: (req: { url: string; init: RequestInit }) => Promise<Response>) {
+  return vi.fn(async (input: RequestInfo, init: RequestInit = {}) => {
+    return handler({ url: typeof input === 'string' ? input : input.toString(), init })
+  })
+}
+
+describe('MatrixClient', () => {
+  it('registers a bot using m.login.application_service and the AS token', async () => {
+    const fetch = fakeFetch(async ({ url, init }) => {
+      expect(url).toBe('https://hs.example.com/_matrix/client/v3/register')
+      expect(init.method).toBe('POST')
+      expect((init.headers as Record<string, string>).Authorization).toBe('Bearer as-secret')
+      expect(JSON.parse(init.body as string)).toEqual({
+        type: 'm.login.application_service',
+        username: 'architect',
+      })
+      return new Response(
+        JSON.stringify({ user_id: '@architect:example.com', device_id: 'D1' }),
+        { status: 200 },
+      )
+    })
+    const client = new MatrixClient({
+      homeserver: 'https://hs.example.com',
+      asToken: 'as-secret',
+      fetch: fetch as unknown as typeof globalThis.fetch,
+    })
+    const user = await client.registerBot('architect')
+    expect(user).toEqual({ user_id: '@architect:example.com', device_id: 'D1' })
+  })
+
+  it('treats M_USER_IN_USE as a no-op (idempotent registration)', async () => {
+    const fetch = fakeFetch(async () =>
+      new Response(JSON.stringify({ errcode: 'M_USER_IN_USE' }), { status: 400 }),
+    )
+    const client = new MatrixClient({
+      homeserver: 'https://hs.example.com',
+      asToken: 'as-secret',
+      fetch: fetch as unknown as typeof globalThis.fetch,
+    })
+    await expect(client.registerBot('architect')).resolves.toBeUndefined()
+  })
+
+  it('joins a room with user_id query parameter for impersonation', async () => {
+    const fetch = fakeFetch(async ({ url, init }) => {
+      expect(url).toBe(
+        'https://hs.example.com/_matrix/client/v3/join/!r%3Aexample.com?user_id=%40architect%3Aexample.com',
+      )
+      expect(init.method).toBe('POST')
+      return new Response(JSON.stringify({ room_id: '!r:example.com' }), { status: 200 })
+    })
+    const client = new MatrixClient({
+      homeserver: 'https://hs.example.com',
+      asToken: 'as-secret',
+      fetch: fetch as unknown as typeof globalThis.fetch,
+    })
+    await client.joinRoom('!r:example.com', '@architect:example.com')
+  })
+
+  it('sends m.room.message via PUT with a unique txnId and m.thread relation', async () => {
+    const fetch = fakeFetch(async ({ url, init }) => {
+      expect(url).toMatch(
+        /^https:\/\/hs\.example\.com\/_matrix\/client\/v3\/rooms\/!r%3Aexample\.com\/send\/m\.room\.message\/[0-9a-f-]+\?user_id=%40architect%3Aexample\.com$/,
+      )
+      expect(init.method).toBe('PUT')
+      const body = JSON.parse(init.body as string)
+      expect(body.msgtype).toBe('m.text')
+      expect(body.body).toBe('reply text')
+      expect(body['m.relates_to']).toEqual({
+        rel_type: 'm.thread',
+        event_id: '$root',
+      })
+      return new Response(JSON.stringify({ event_id: '$x' }), { status: 200 })
+    })
+    const client = new MatrixClient({
+      homeserver: 'https://hs.example.com',
+      asToken: 'as-secret',
+      fetch: fetch as unknown as typeof globalThis.fetch,
+    })
+    await client.sendMessage({
+      roomId: '!r:example.com',
+      asUserId: '@architect:example.com',
+      content: { msgtype: 'm.text', body: 'reply text' },
+      threadRoot: '$root',
+    })
+  })
+
+  it('resolveAlias returns the room id when the homeserver knows the alias', async () => {
+    const fetch = fakeFetch(async ({ url }) => {
+      expect(url).toBe(
+        'https://hs.example.com/_matrix/client/v3/directory/room/%23welcome%3Alocalhost',
+      )
+      return new Response(JSON.stringify({ room_id: '!abc:localhost' }), { status: 200 })
+    })
+    const client = new MatrixClient({
+      homeserver: 'https://hs.example.com',
+      asToken: 'as-secret',
+      fetch: fetch as unknown as typeof globalThis.fetch,
+    })
+    expect(await client.resolveAlias('#welcome:localhost')).toBe('!abc:localhost')
+  })
+
+  it('resolveAlias returns null on M_NOT_FOUND', async () => {
+    const fetch = fakeFetch(async () =>
+      new Response(JSON.stringify({ errcode: 'M_NOT_FOUND' }), { status: 404 }),
+    )
+    const client = new MatrixClient({
+      homeserver: 'https://hs.example.com',
+      asToken: 'as-secret',
+      fetch: fetch as unknown as typeof globalThis.fetch,
+    })
+    expect(await client.resolveAlias('#nope:localhost')).toBeNull()
+  })
+
+  it('createRoom POSTs /createRoom impersonating the sender user', async () => {
+    const fetch = fakeFetch(async ({ url, init }) => {
+      expect(url).toMatch(
+        /\/_matrix\/client\/v3\/createRoom\?user_id=%40admin%3Alocalhost$/,
+      )
+      expect(init.method).toBe('POST')
+      const body = JSON.parse(init.body as string)
+      expect(body).toMatchObject({
+        room_alias_name: 'welcome',
+        preset: 'public_chat',
+        invite: ['@admin:localhost'],
+      })
+      return new Response(JSON.stringify({ room_id: '!new:localhost' }), { status: 200 })
+    })
+    const client = new MatrixClient({
+      homeserver: 'https://hs.example.com',
+      asToken: 'as-secret',
+      fetch: fetch as unknown as typeof globalThis.fetch,
+    })
+    const id = await client.createRoom({
+      roomAliasName: 'welcome',
+      invite: ['@admin:localhost'],
+      senderUserId: '@admin:localhost',
+    })
+    expect(id).toBe('!new:localhost')
+  })
+
+  it('createRoom passes optional name as m.room.name when supplied', async () => {
+    const fetch = fakeFetch(async ({ init }) => {
+      const body = JSON.parse(init.body as string)
+      expect(body.name).toBe('Welcome Aboard')
+      return new Response(JSON.stringify({ room_id: '!new:localhost' }), { status: 200 })
+    })
+    const client = new MatrixClient({
+      homeserver: 'https://hs.example.com',
+      asToken: 'as-secret',
+      fetch: fetch as unknown as typeof globalThis.fetch,
+    })
+    await client.createRoom({
+      roomAliasName: 'welcome',
+      invite: [],
+      senderUserId: '@admin:localhost',
+      name: 'Welcome Aboard',
+    })
+  })
+
+  it('setDisplayName PUTs the displayname endpoint impersonating the user', async () => {
+    const fetch = fakeFetch(async ({ url, init }) => {
+      expect(url).toBe(
+        'https://hs.example.com/_matrix/client/v3/profile/%40docs%3Alocalhost/displayname' +
+          '?user_id=%40docs%3Alocalhost',
+      )
+      expect(init.method).toBe('PUT')
+      expect(JSON.parse(init.body as string)).toEqual({ displayname: 'Docs Agent' })
+      return new Response('{}', { status: 200 })
+    })
+    const client = new MatrixClient({
+      homeserver: 'https://hs.example.com',
+      asToken: 'as-secret',
+      fetch: fetch as unknown as typeof globalThis.fetch,
+    })
+    await client.setDisplayName('@docs:localhost', 'Docs Agent')
+  })
+
+  describe('MatrixClient.setTyping', () => {
+    it('PUTs typing=true with timeout to the typing endpoint, impersonating the asUserId', async () => {
+      const fetch = fakeFetch(async ({ url, init }) => {
+        expect(url).toBe(
+          'https://hs.example.com/_matrix/client/v3/rooms/!r%3Aexample.com/typing/%40architect%3Aexample.com' +
+            '?user_id=%40architect%3Aexample.com',
+        )
+        expect(init.method).toBe('PUT')
+        expect((init.headers as Record<string, string>).Authorization).toBe('Bearer as-secret')
+        expect(JSON.parse(init.body as string)).toEqual({ typing: true, timeout: 30000 })
+        return new Response('{}', { status: 200 })
+      })
+      const client = new MatrixClient({
+        homeserver: 'https://hs.example.com',
+        asToken: 'as-secret',
+        fetch: fetch as unknown as typeof globalThis.fetch,
+      })
+      await client.setTyping({
+        roomId: '!r:example.com',
+        asUserId: '@architect:example.com',
+        typing: true,
+        timeoutMs: 30_000,
+      })
+    })
+
+    it('PUTs typing=false without timeout to clear', async () => {
+      const fetch = fakeFetch(async ({ init }) => {
+        expect(JSON.parse(init.body as string)).toEqual({ typing: false })
+        return new Response('{}', { status: 200 })
+      })
+      const client = new MatrixClient({
+        homeserver: 'https://hs.example.com',
+        asToken: 'as-secret',
+        fetch: fetch as unknown as typeof globalThis.fetch,
+      })
+      await client.setTyping({
+        roomId: '!r:example.com',
+        asUserId: '@architect:example.com',
+        typing: false,
+      })
+    })
+
+    it('throws on non-2xx', async () => {
+      const fetch = fakeFetch(async () => new Response('boom', { status: 500 }))
+      const client = new MatrixClient({
+        homeserver: 'https://hs.example.com',
+        asToken: 'as-secret',
+        fetch: fetch as unknown as typeof globalThis.fetch,
+      })
+      await expect(
+        client.setTyping({ roomId: '!r', asUserId: '@a:x', typing: true }),
+      ).rejects.toThrow(/setTyping/)
+    })
+  })
+
+  describe('MatrixClient.setPresence', () => {
+    it('PUTs presence to the presence/status endpoint, impersonating the asUserId', async () => {
+      const fetch = fakeFetch(async ({ url, init }) => {
+        expect(url).toBe(
+          'https://hs.example.com/_matrix/client/v3/presence/%40architect%3Aexample.com/status' +
+            '?user_id=%40architect%3Aexample.com',
+        )
+        expect(init.method).toBe('PUT')
+        expect(JSON.parse(init.body as string)).toEqual({ presence: 'online' })
+        return new Response('{}', { status: 200 })
+      })
+      const client = new MatrixClient({
+        homeserver: 'https://hs.example.com',
+        asToken: 'as-secret',
+        fetch: fetch as unknown as typeof globalThis.fetch,
+      })
+      await client.setPresence({ asUserId: '@architect:example.com', presence: 'online' })
+    })
+
+    it('includes status_msg when provided', async () => {
+      const fetch = fakeFetch(async ({ init }) => {
+        expect(JSON.parse(init.body as string)).toEqual({
+          presence: 'unavailable',
+          status_msg: 'running prompt',
+        })
+        return new Response('{}', { status: 200 })
+      })
+      const client = new MatrixClient({
+        homeserver: 'https://hs.example.com',
+        asToken: 'as-secret',
+        fetch: fetch as unknown as typeof globalThis.fetch,
+      })
+      await client.setPresence({
+        asUserId: '@architect:example.com',
+        presence: 'unavailable',
+        statusMsg: 'running prompt',
+      })
+    })
+
+    it('throws on non-2xx', async () => {
+      const fetch = fakeFetch(async () => new Response('nope', { status: 403 }))
+      const client = new MatrixClient({
+        homeserver: 'https://hs.example.com',
+        asToken: 'as-secret',
+        fetch: fetch as unknown as typeof globalThis.fetch,
+      })
+      await expect(
+        client.setPresence({ asUserId: '@a:x', presence: 'online' }),
+      ).rejects.toThrow(/setPresence/)
+    })
+  })
+
+  it('sends a custom event type when content type is set', async () => {
+    const fetch = fakeFetch(async ({ url, init }) => {
+      expect(url).toMatch(/\/send\/eco\.zoon\.approval_request\//)
+      const body = JSON.parse(init.body as string)
+      expect(body.approval_id).toBe('a1')
+      return new Response(JSON.stringify({ event_id: '$x' }), { status: 200 })
+    })
+    const client = new MatrixClient({
+      homeserver: 'https://hs.example.com',
+      asToken: 'as-secret',
+      fetch: fetch as unknown as typeof globalThis.fetch,
+    })
+    await client.sendCustomEvent({
+      roomId: '!r:example.com',
+      asUserId: '@architect:example.com',
+      eventType: 'eco.zoon.approval_request',
+      content: { approval_id: 'a1', description: 'Run: git push' },
+    })
+  })
+})