opencode-discord-bot 0.0.1

package/src/Discord/ChatSdkDiscord.ts

@@ -0,0 +1,206 @@
+import { readFile } from "node:fs/promises"
+import { basename } from "node:path"
+import { createDiscordAdapter, type DiscordThreadId } from "@chat-adapter/discord"
+import type { AdapterPostableMessage, ChannelInfo, FetchOptions, FetchResult, Message, PostableRaw, RawMessage } from "chat"
+import { Duration, Effect } from "effect"
+import type { DiscordAttachment, DiscordMessage, DiscordScope } from "../Schema.ts"
+import { DiscordError, type DiscordService } from "./DiscordPort.ts"
+
+type ChatDiscordAdapter = {
+  readonly encodeThreadId: (input: DiscordThreadId) => string
+  readonly postMessage: (threadId: string, message: AdapterPostableMessage) => Promise<RawMessage<unknown>>
+  readonly postChannelMessage: (channelId: string, message: AdapterPostableMessage) => Promise<RawMessage<unknown>>
+  readonly editMessage: (threadId: string, messageId: string, message: AdapterPostableMessage) => Promise<RawMessage<unknown>>
+  readonly deleteMessage: (threadId: string, messageId: string) => Promise<void>
+  readonly startTyping: (threadId: string, status?: string) => Promise<void>
+  readonly addReaction: (threadId: string, messageId: string, emoji: string) => Promise<void>
+  readonly removeReaction: (threadId: string, messageId: string, emoji: string) => Promise<void>
+  readonly fetchMessages: (threadId: string, options?: FetchOptions) => Promise<FetchResult<unknown>>
+  readonly fetchChannelInfo?: ((channelId: string) => Promise<ChannelInfo>) | undefined
+}
+
+type LiveDiscordOptions = {
+  readonly botToken: string
+  readonly applicationId?: string
+  readonly publicKey?: string
+}
+
+const threadIdFromScope = (adapter: ChatDiscordAdapter, scope: DiscordScope): string =>
+  adapter.encodeThreadId({
+    guildId: scope.guildId,
+    channelId: scope.channelId,
+    ...(scope.threadId === undefined ? {} : { threadId: scope.threadId })
+  })
+
+const mentions = (content: string): ReadonlyArray<string> => [...content.matchAll(/<@(\d+)>/g)].map((match) => match[1] ?? "")
+
+const isRecord = (value: unknown): value is Readonly<Record<string, unknown>> =>
+  typeof value === "object" && value !== null && !Array.isArray(value)
+
+const stringField = (record: Readonly<Record<string, unknown>>, key: string): string | undefined => {
+  const value = record[key]
+  return typeof value === "string" ? value : undefined
+}
+
+const attachments = (message: Message<unknown>): ReadonlyArray<DiscordAttachment> =>
+  message.attachments.map((item, index) => ({
+    id: `${message.id}-${index}`,
+    filename: item.name ?? `attachment-${index + 1}`,
+    ...(item.mimeType === undefined ? {} : { contentType: item.mimeType }),
+    size: item.size ?? 0,
+    url: item.url ?? ""
+  }))
+
+const fromChatMessage = (scope: DiscordScope, message: Message<unknown>): DiscordMessage => ({
+  id: message.id,
+  guildId: scope.guildId,
+  channelId: scope.channelId,
+  ...(scope.threadId === undefined ? {} : { threadId: scope.threadId }),
+  author: {
+    id: message.author.userId,
+    displayName: message.author.fullName,
+    nickname: message.author.userName,
+    isBot: message.author.isBot === true
+  },
+  content: message.text,
+  timestamp: message.metadata.dateSent.toISOString(),
+  mentions: mentions(message.text),
+  roleMentions: [...message.text.matchAll(/<@&(\d+)>/g)].map((match) => match[1] ?? ""),
+  everyoneMention: message.text.includes("@everyone"),
+  hereMention: message.text.includes("@here"),
+  attachments: attachments(message),
+  reactions: [],
+  channelType: "guild"
+})
+
+const retryAfterFromCause = (cause: unknown) => {
+  if (!isRecord(cause)) return undefined
+  const retryAfter = cause.retryAfter
+  if (Duration.isDuration(retryAfter)) return retryAfter
+  if (typeof cause.retryAfterMs === "number" && Number.isFinite(cause.retryAfterMs) && cause.retryAfterMs >= 0) {
+    return Duration.millis(cause.retryAfterMs)
+  }
+  if (typeof retryAfter === "number" && Number.isFinite(retryAfter) && retryAfter >= 0) return Duration.millis(retryAfter * 1000)
+  if (typeof cause.retry_after === "number" && Number.isFinite(cause.retry_after) && cause.retry_after >= 0) {
+    return Duration.millis(cause.retry_after * 1000)
+  }
+  return undefined
+}
+
+const validateGuildChannel = async (adapter: ChatDiscordAdapter, guildId: string, channelThreadId: string): Promise<void> => {
+  if (adapter.fetchChannelInfo === undefined) return
+  const info = await adapter.fetchChannelInfo(channelThreadId)
+  if (info.isDM === true) throw new DiscordError({ message: "Discord DMs are not supported" })
+  const raw = info.metadata.raw
+  const actualGuildId = isRecord(raw) ? stringField(raw, "guild_id") : undefined
+  if (actualGuildId !== undefined && actualGuildId !== guildId) {
+    throw new DiscordError({ message: "Discord channel does not belong to the requested guild" })
+  }
+}
+
+const tryAdapter = <A>(operation: () => Promise<A>): Effect.Effect<A, DiscordError> =>
+  Effect.tryPromise({
+    try: operation,
+    catch: (cause) =>
+      cause instanceof DiscordError
+        ? cause
+        : new DiscordError({
+            message: cause instanceof Error ? cause.message : "chat-sdk Discord operation failed",
+            retryAfter: retryAfterFromCause(cause)
+          })
+  })
+
+const retryAfterHeader = (response: Response) => {
+  const value = response.headers.get("retry-after")
+  if (value === null) return undefined
+  const seconds = Number(value)
+  return Number.isFinite(seconds) && seconds >= 0 ? Duration.millis(seconds * 1000) : undefined
+}
+
+type RawDiscordOptions = {
+  readonly botToken: string
+  readonly apiUrl?: string | undefined
+}
+
+const rawDiscord = (options: RawDiscordOptions | undefined, path: string, init: RequestInit): Effect.Effect<unknown, DiscordError> =>
+  tryAdapter(async () => {
+    if (options === undefined) throw new Error("Discord adapter does not expose this operation")
+    const response = await fetch(`${options.apiUrl ?? "https://discord.com/api/v10"}${path}`, {
+      ...init,
+      headers: {
+        authorization: `Bot ${options.botToken}`,
+        "content-type": "application/json",
+        ...init.headers
+      }
+    })
+    if (!response.ok)
+      throw new DiscordError({
+        message: `Discord REST ${response.status}: ${await response.text()}`,
+        retryAfter: retryAfterHeader(response)
+      })
+    if (response.status === 204) return {}
+    return await response.json()
+  })
+
+export const makeChatSdkDiscord = (adapter: ChatDiscordAdapter, raw: RawDiscordOptions | undefined = undefined): DiscordService => ({
+  fetchContext: (scope, limit) =>
+    tryAdapter(async () => {
+      const threadId = threadIdFromScope(adapter, scope)
+      const result = await adapter.fetchMessages(threadId, { limit })
+      return result.messages.map((message) => fromChatMessage(scope, message))
+    }),
+  fetchHistory: (scope, limit) =>
+    tryAdapter(async () => {
+      const threadId = threadIdFromScope(adapter, scope)
+      const result = await adapter.fetchMessages(threadId, { limit })
+      return result.messages.map((message) => fromChatMessage(scope, message))
+    }),
+  sendTyping: (scope) => tryAdapter(() => adapter.startTyping(threadIdFromScope(adapter, scope))).pipe(Effect.asVoid),
+  postMessage: (scope, content) =>
+    tryAdapter(async () => {
+      const result = await adapter.postMessage(threadIdFromScope(adapter, scope), content)
+      return { id: result.id }
+    }),
+  editMessage: (scope, messageId, content) =>
+    tryAdapter(() => adapter.editMessage(threadIdFromScope(adapter, scope), messageId, content)).pipe(Effect.asVoid),
+  deleteMessage: (scope, messageId) =>
+    tryAdapter(() => adapter.deleteMessage(threadIdFromScope(adapter, scope), messageId)).pipe(Effect.asVoid),
+  addReaction: (scope, messageId, emoji) =>
+    tryAdapter(() => adapter.addReaction(threadIdFromScope(adapter, scope), messageId, emoji)).pipe(Effect.asVoid),
+  removeReaction: (scope, messageId, emoji) =>
+    tryAdapter(() => adapter.removeReaction(threadIdFromScope(adapter, scope), messageId, emoji)).pipe(Effect.asVoid),
+  attachFile: (scope, path) =>
+    tryAdapter(async () => {
+      const file: PostableRaw = { raw: "", files: [{ filename: basename(path), data: await readFile(path) }] }
+      const result = await adapter.postMessage(threadIdFromScope(adapter, scope), file)
+      return { path: result.id }
+    }),
+  createThread: (scope, name) =>
+    rawDiscord(raw, `/channels/${scope.channelId}/threads`, {
+      method: "POST",
+      body: JSON.stringify({ name, type: 11 })
+    }).pipe(Effect.map((data) => ({ id: isRecord(data) && typeof data.id === "string" ? data.id : "" }))),
+  postChannelMessage: (guildId, channelId, content) =>
+    tryAdapter(async () => {
+      const encodedChannelId = adapter.encodeThreadId({ guildId, channelId })
+      await validateGuildChannel(adapter, guildId, encodedChannelId)
+      const result = await adapter.postChannelMessage(encodedChannelId, sanitizeGuildContent(guildId, content))
+      return { id: result.id }
+    }),
+  pinMessage: (scope, messageId) =>
+    rawDiscord(raw, `/channels/${scope.threadId ?? scope.channelId}/pins/${messageId}`, { method: "PUT" }).pipe(Effect.asVoid),
+  unpinMessage: (scope, messageId) =>
+    rawDiscord(raw, `/channels/${scope.threadId ?? scope.channelId}/pins/${messageId}`, { method: "DELETE" }).pipe(Effect.asVoid)
+})
+
+const sanitizeGuildContent = (_guildId: string, content: string): string => content
+
+export const makeLiveChatSdkDiscord = (options: LiveDiscordOptions): DiscordService =>
+  makeChatSdkDiscord(
+    createDiscordAdapter({
+      botToken: options.botToken,
+      ...(options.applicationId === undefined ? {} : { applicationId: options.applicationId }),
+      publicKey: options.publicKey ?? "0".repeat(64)
+    }),
+    { botToken: options.botToken }
+  )

package/src/Discord/ChatSdkGatewayIntake.test.ts

@@ -0,0 +1,121 @@
+import { expect, test } from "bun:test"
+import { Message, parseMarkdown } from "chat"
+import { Effect } from "effect"
+import type { DiscordMessage } from "../Schema.ts"
+import { collectDiscordMessages, makeChatGatewayIntake, makeGatewayAdapter, makeTransientChatState } from "./ChatSdkGatewayIntake.ts"
+
+const message = {
+  id: "m1",
+  guildId: "g1",
+  channelId: "c1",
+  author: { id: "u1", displayName: "Alice", isBot: false },
+  content: "hello <@self>",
+  timestamp: "2026-06-05T14:03:00.000Z",
+  mentions: ["self"],
+  roleMentions: [],
+  everyoneMention: false,
+  hereMention: false,
+  attachments: [],
+  reactions: [],
+  channelType: "guild"
+} satisfies DiscordMessage
+
+test("processes gateway messages through chat-sdk intake and dedupes retries", async () => {
+  const seen: Array<readonly [string, number]> = []
+  const intake = makeChatGatewayIntake({
+    bot: { userId: "self" },
+    onMessage: (next, skipped) => Effect.sync(() => seen.push([next.id, skipped.length]))
+  })
+
+  await Effect.runPromise(intake.processMessage(message))
+  await Effect.runPromise(intake.processMessage(message))
+
+  expect(seen).toEqual([["m1", 0]])
+})
+
+test("maps Discord messages through the chat-sdk adapter facade", async () => {
+  const adapter = makeGatewayAdapter({ userId: "self" })
+  const withAttachment = {
+    ...message,
+    attachments: [{ id: "a1", filename: "screen.png", contentType: "image/png", size: 10, url: "https://cdn/screen.png" }]
+  } satisfies DiscordMessage
+  const parsed = adapter.parseMessage(withAttachment)
+
+  expect(adapter.encodeThreadId({ guildId: "g1", channelId: "c1", threadId: "t1" })).toBe("discord:g1:c1:t1")
+  expect(adapter.decodeThreadId("discord:g1:c1:t1")).toEqual({ guildId: "g1", channelId: "c1", threadId: "t1" })
+  expect(adapter.channelIdFromThreadId("discord:g1:c1:t1")).toBe("c1")
+  expect(parsed.threadId).toBe("discord:g1:c1")
+  expect(parsed.attachments).toEqual([
+    { type: "image", name: "screen.png", mimeType: "image/png", size: 10, url: "https://cdn/screen.png" }
+  ])
+  expect(adapter.renderFormatted(parsed.formatted)).toContain("hello")
+  expect(await adapter.fetchMessages("discord:g1:c1")).toEqual({ messages: [] })
+  expect(await adapter.fetchThread("discord:g1:c1:t1")).toEqual({ id: "discord:g1:c1:t1", channelId: "c1", isDM: false, metadata: {} })
+  expect(adapter.isDM?.("discord:g1:c1")).toBe(false)
+  expect(await adapter.handleWebhook(new Request("http://localhost"))).toHaveProperty("status", 404)
+})
+
+test("rejects output operations on the gateway intake adapter facade", async () => {
+  const adapter = makeGatewayAdapter({ userId: "self" })
+
+  await expect(adapter.postMessage("discord:g1:c1", "hello")).rejects.toThrow("cannot post messages")
+  if (adapter.postChannelMessage === undefined) throw new Error("missing postChannelMessage")
+  await expect(adapter.postChannelMessage("discord:g1:c1", "hello")).rejects.toThrow("cannot post channel messages")
+  await expect(adapter.editMessage("discord:g1:c1", "m1", "hello")).rejects.toThrow("cannot edit messages")
+  await expect(adapter.deleteMessage("discord:g1:c1", "m1")).rejects.toThrow("cannot delete messages")
+  await expect(adapter.addReaction("discord:g1:c1", "m1", "rocket")).rejects.toThrow("cannot add reactions")
+  await expect(adapter.removeReaction("discord:g1:c1", "m1", "rocket")).rejects.toThrow("cannot remove reactions")
+  await expect(adapter.startTyping("discord:g1:c1")).rejects.toThrow("cannot start typing")
+})
+
+test("provides transient in-memory chat-sdk state", async () => {
+  const state = makeTransientChatState()
+  const adapter = makeGatewayAdapter({ userId: "self" })
+  const parsed = adapter.parseMessage(message)
+
+  await state.connect()
+  expect(await state.setIfNotExists("dedupe", true, 1000)).toBe(true)
+  expect(await state.setIfNotExists("dedupe", true, 1000)).toBe(false)
+  await state.set("expired", true, -1)
+  expect(await state.setIfNotExists("expired", true, 1000)).toBe(true)
+  await state.delete("dedupe")
+  await state.appendToList("list", "a", { maxLength: 1 })
+  expect(await state.getList("list")).toEqual([])
+
+  const lock = await state.acquireLock("thread", 1000)
+  if (lock === null) throw new Error("expected lock")
+  expect(await state.acquireLock("thread", 1000)).toBeNull()
+  expect(await state.extendLock(lock, 1000)).toBe(true)
+  await state.releaseLock(lock)
+  expect(await state.extendLock(lock, 1000)).toBe(false)
+  await state.forceReleaseLock("thread")
+
+  expect(await state.enqueue("thread", { message: parsed, enqueuedAt: 0, expiresAt: Date.now() - 1 }, 10)).toBe(1)
+  expect(await state.enqueue("thread", { message: parsed, enqueuedAt: 0, expiresAt: Date.now() + 1000 }, 1)).toBe(1)
+  expect(await state.queueDepth("thread")).toBe(1)
+  expect(await state.dequeue("thread")).toMatchObject({ message: parsed })
+  expect(await state.dequeue("thread")).toBeNull()
+
+  await state.subscribe("thread")
+  expect(await state.isSubscribed("thread")).toBe(true)
+  await state.unsubscribe("thread")
+  expect(await state.isSubscribed("thread")).toBe(false)
+  await state.disconnect()
+})
+
+test("filters non-Discord raw messages from skipped chat context", () => {
+  const adapter = makeGatewayAdapter({ userId: "self" })
+  const valid = adapter.parseMessage(message)
+  const invalid = new Message({
+    id: "invalid",
+    threadId: "discord:g1:c1",
+    text: "invalid",
+    formatted: parseMarkdown("invalid"),
+    raw: {},
+    author: { userId: "u1", userName: "alice", fullName: "Alice", isBot: false, isMe: false },
+    metadata: { dateSent: new Date("2026-06-05T14:03:00.000Z"), edited: false },
+    attachments: []
+  })
+
+  expect(collectDiscordMessages([invalid, valid])).toEqual([message])
+})

package/src/Discord/ChatSdkGatewayIntake.ts

@@ -0,0 +1,235 @@
+import {
+  type Adapter,
+  type Attachment,
+  Chat,
+  type FetchOptions,
+  type FetchResult,
+  type Lock,
+  Message,
+  type MessageContext,
+  parseMarkdown,
+  type QueueEntry,
+  type StateAdapter,
+  stringifyMarkdown
+} from "chat"
+import { Effect } from "effect"
+import type { BotIdentity, DiscordAttachment, DiscordMessage, DiscordScope } from "../Schema.ts"
+
+export type ChatGatewayIntake = {
+  readonly processMessage: (message: DiscordMessage) => Effect.Effect<void, unknown>
+}
+
+type ChatGatewayIntakeOptions = {
+  readonly bot: BotIdentity
+  readonly onMessage: (message: DiscordMessage, skippedMessages: ReadonlyArray<DiscordMessage>) => Effect.Effect<void, unknown>
+}
+
+type StoredValue = {
+  readonly value: unknown
+  readonly expiresAt?: number | undefined
+}
+
+const threadIdFromMessage = (message: DiscordMessage): string =>
+  message.threadId === undefined
+    ? `discord:${message.guildId}:${message.channelId}`
+    : `discord:${message.guildId}:${message.channelId}:${message.threadId}`
+
+const scopeFromThreadId = (threadId: string): DiscordScope => {
+  const [, guildId = "", channelId = "", threadIdPart = channelId] = threadId.split(":")
+  return threadIdPart === channelId ? { guildId, channelId } : { guildId, channelId, threadId: threadIdPart }
+}
+
+const chatAttachment = (attachment: DiscordAttachment): Attachment => ({
+  type: attachment.contentType?.startsWith("image/") ? "image" : "file",
+  name: attachment.filename,
+  size: attachment.size,
+  url: attachment.url,
+  ...(attachment.contentType === undefined ? {} : { mimeType: attachment.contentType })
+})
+
+const isDiscordMessage = (value: unknown): value is DiscordMessage =>
+  typeof value === "object" &&
+  value !== null &&
+  "id" in value &&
+  typeof value.id === "string" &&
+  "guildId" in value &&
+  typeof value.guildId === "string" &&
+  "channelId" in value &&
+  typeof value.channelId === "string"
+
+const toChatMessage = (message: DiscordMessage, bot: BotIdentity): Message<DiscordMessage> =>
+  new Message({
+    id: message.id,
+    threadId: threadIdFromMessage(message),
+    text: message.content,
+    formatted: parseMarkdown(message.content),
+    raw: message,
+    author: {
+      userId: message.author.id,
+      userName: message.author.nickname ?? message.author.displayName,
+      fullName: message.author.displayName,
+      isBot: message.author.isBot,
+      isMe: message.author.id === bot.userId
+    },
+    metadata: { dateSent: new Date(message.timestamp), edited: false },
+    attachments: message.attachments.map(chatAttachment),
+    isMention: message.mentions.includes(bot.userId)
+  })
+
+const fromChatMessage = (message: Message<unknown>): DiscordMessage | undefined => (isDiscordMessage(message.raw) ? message.raw : undefined)
+
+export const collectDiscordMessages = (messages: Iterable<Message<unknown>>): ReadonlyArray<DiscordMessage> => {
+  const collected: Array<DiscordMessage> = []
+  for (const message of messages) {
+    const discordMessage = fromChatMessage(message)
+    if (discordMessage !== undefined) collected.push(discordMessage)
+  }
+  return collected
+}
+
+const liveValue = (stored: StoredValue | undefined): unknown | undefined => {
+  if (stored === undefined) return undefined
+  if (stored.expiresAt !== undefined && stored.expiresAt <= Date.now()) return undefined
+  return stored.value
+}
+
+export const makeTransientChatState = (): StateAdapter => {
+  const values = new Map<string, StoredValue>()
+  const lists = new Map<string, Array<unknown>>()
+  const queues = new Map<string, Array<QueueEntry>>()
+  const locks = new Map<string, Lock>()
+  const subscribed = new Set<string>()
+
+  return {
+    connect: () => Promise.resolve(),
+    disconnect: () => Promise.resolve(),
+    get: () => Promise.resolve(null),
+    set: (key, value, ttlMs) => {
+      values.set(key, { value, ...(ttlMs === undefined ? {} : { expiresAt: Date.now() + ttlMs }) })
+      return Promise.resolve()
+    },
+    setIfNotExists: (key, value, ttlMs) => {
+      if (liveValue(values.get(key)) !== undefined) return Promise.resolve(false)
+      values.set(key, { value, ...(ttlMs === undefined ? {} : { expiresAt: Date.now() + ttlMs }) })
+      return Promise.resolve(true)
+    },
+    delete: (key) => {
+      values.delete(key)
+      return Promise.resolve()
+    },
+    appendToList: (key, value, options) => {
+      const next = [...(lists.get(key) ?? []), value].slice(-(options?.maxLength ?? Number.POSITIVE_INFINITY))
+      lists.set(key, next)
+      return Promise.resolve()
+    },
+    getList: () => Promise.resolve([]),
+    acquireLock: (threadId, ttlMs) => {
+      const existing = locks.get(threadId)
+      if (existing !== undefined && existing.expiresAt > Date.now()) return Promise.resolve(null)
+      const lock = { threadId, token: crypto.randomUUID(), expiresAt: Date.now() + ttlMs }
+      locks.set(threadId, lock)
+      return Promise.resolve(lock)
+    },
+    extendLock: (lock, ttlMs) => {
+      if (locks.get(lock.threadId)?.token !== lock.token) return Promise.resolve(false)
+      locks.set(lock.threadId, { ...lock, expiresAt: Date.now() + ttlMs })
+      return Promise.resolve(true)
+    },
+    releaseLock: (lock) => {
+      if (locks.get(lock.threadId)?.token === lock.token) locks.delete(lock.threadId)
+      return Promise.resolve()
+    },
+    forceReleaseLock: (threadId) => {
+      locks.delete(threadId)
+      return Promise.resolve()
+    },
+    enqueue: (threadId, entry, maxSize) => {
+      const next = [...(queues.get(threadId) ?? []), entry].slice(-maxSize)
+      queues.set(threadId, next)
+      return Promise.resolve(next.length)
+    },
+    dequeue: (threadId) => {
+      const queue = queues.get(threadId) ?? []
+      const now = Date.now()
+      while (queue.length > 0) {
+        const entry = queue.shift()
+        if (entry !== undefined && entry.expiresAt > now) return Promise.resolve(entry)
+      }
+      queues.delete(threadId)
+      return Promise.resolve(null)
+    },
+    queueDepth: (threadId) => Promise.resolve(queues.get(threadId)?.length ?? 0),
+    subscribe: (threadId) => {
+      subscribed.add(threadId)
+      return Promise.resolve()
+    },
+    unsubscribe: (threadId) => {
+      subscribed.delete(threadId)
+      return Promise.resolve()
+    },
+    isSubscribed: (threadId) => Promise.resolve(subscribed.has(threadId))
+  }
+}
+
+const unsupported = (operation: string): Promise<never> => Promise.reject(new Error(`chat-sdk gateway intake cannot ${operation}`))
+
+export const makeGatewayAdapter = (bot: BotIdentity): Adapter<DiscordScope, DiscordMessage> => ({
+  name: "discord",
+  userName: `<@${bot.userId}>`,
+  botUserId: bot.userId,
+  lockScope: "thread",
+  initialize: () => Promise.resolve(),
+  handleWebhook: () => Promise.resolve(new Response(null, { status: 404 })),
+  encodeThreadId: (scope) =>
+    scope.threadId === undefined
+      ? `discord:${scope.guildId}:${scope.channelId}`
+      : `discord:${scope.guildId}:${scope.channelId}:${scope.threadId}`,
+  decodeThreadId: scopeFromThreadId,
+  channelIdFromThreadId: (threadId) => scopeFromThreadId(threadId).channelId,
+  parseMessage: (raw) => toChatMessage(raw, bot),
+  renderFormatted: (content) => stringifyMarkdown(content),
+  fetchMessages: (_threadId, _options?: FetchOptions): Promise<FetchResult<DiscordMessage>> => Promise.resolve({ messages: [] }),
+  fetchThread: (threadId) => {
+    const scope = scopeFromThreadId(threadId)
+    return Promise.resolve({ id: threadId, channelId: scope.channelId, isDM: false, metadata: {} })
+  },
+  isDM: () => false,
+  postMessage: () => unsupported("post messages"),
+  postChannelMessage: () => unsupported("post channel messages"),
+  editMessage: () => unsupported("edit messages"),
+  deleteMessage: () => unsupported("delete messages"),
+  addReaction: () => unsupported("add reactions"),
+  removeReaction: () => unsupported("remove reactions"),
+  startTyping: () => unsupported("start typing")
+})
+
+export const makeChatGatewayIntake = (options: ChatGatewayIntakeOptions): ChatGatewayIntake => {
+  const adapter = makeGatewayAdapter(options.bot)
+  const chat = new Chat({
+    adapters: { discord: adapter },
+    state: makeTransientChatState(),
+    userName: `<@${options.bot.userId}>`,
+    concurrency: "concurrent",
+    dedupeTtlMs: 5 * 60 * 1000
+  })
+
+  const handle = (message: Message<unknown>, context?: MessageContext) => {
+    const current = fromChatMessage(message)
+    if (current === undefined) return Promise.resolve()
+    const skipped = collectDiscordMessages(context?.skipped ?? [])
+    return Effect.runPromise(options.onMessage(current, skipped))
+  }
+
+  const dispatch = (_thread: unknown, message: Message<unknown>, context?: MessageContext) => handle(message, context)
+  chat.onNewMention(dispatch)
+  chat.onSubscribedMessage(dispatch)
+  chat.onNewMessage(/[\s\S]*/, dispatch)
+
+  return {
+    processMessage: (message) =>
+      Effect.tryPromise({
+        try: () => chat.processMessage(adapter, threadIdFromMessage(message), toChatMessage(message, options.bot)),
+        catch: (cause) => cause
+      })
+  }
+}