opencode-discord-bot 0.0.1

package/src/Config.ts

@@ -0,0 +1,295 @@
+import { readFile } from "node:fs/promises"
+import { join } from "node:path"
+import { Data, Duration, Effect, Redacted, Schema } from "effect"
+import { type ParseError, parse } from "jsonc-parser"
+import { RawConfigSchema } from "./ConfigSchema.ts"
+import type { ConfigSources, LoadConfigOptions } from "./ConfigTypes.ts"
+
+export type { ConfigSources, LoadConfigOptions } from "./ConfigTypes.ts"
+
+export class ConfigError extends Data.TaggedError("ConfigError")<{
+  readonly message: string
+}> {}
+
+export type ToolConfig = {
+  readonly enabled: boolean
+  readonly autoInstall: boolean
+  readonly reactions: boolean
+  readonly attachFiles: boolean
+  readonly fetchHistory: boolean
+  readonly followUpMessages: boolean
+  readonly createThread: boolean
+  readonly editDeleteOwn: boolean
+  readonly postOtherChannels: boolean
+  readonly pin: boolean
+}
+
+export type RuntimeConfig = {
+  readonly discordToken: Redacted.Redacted<string>
+  readonly discord: {
+    readonly applicationId?: string
+    readonly publicKey?: string
+    readonly guildId?: string
+  }
+  readonly opencode: {
+    readonly port: number
+    readonly baseUrl: string
+    readonly projectDir: string
+    readonly model?: string
+    readonly agent?: string
+  }
+  readonly bridge: {
+    readonly host: "127.0.0.1"
+    readonly port: number
+  }
+  readonly context: {
+    readonly messages: number
+    readonly maxChars: number
+    readonly attachmentMaxBytes: number
+  }
+  readonly threads: {
+    readonly activeByRecentBotParticipation: boolean
+  }
+  readonly tools: ToolConfig
+  readonly streaming: {
+    readonly updateInterval: Duration.Duration
+    readonly placeholderText: string | null
+    readonly showToolStatus: boolean
+    readonly changedFilesSummary: boolean
+  }
+  readonly concurrency: {
+    readonly strategy: "queue" | "burst"
+    readonly lockScope: "discord-scope"
+    readonly globalMaxActiveTurns: number | null
+  }
+  readonly guards: {
+    readonly ignoreBots: boolean
+    readonly stripMassMentions: boolean
+    readonly redactSecretsInErrors: boolean
+    readonly maxTurn: Duration.Duration | null
+  }
+}
+
+export const defaultConfig: RuntimeConfig = {
+  discordToken: Redacted.make(""),
+  discord: {},
+  opencode: {
+    port: 4096,
+    baseUrl: "http://127.0.0.1:4096",
+    projectDir: process.cwd()
+  },
+  bridge: {
+    host: "127.0.0.1",
+    port: 8787
+  },
+  context: {
+    messages: 30,
+    maxChars: 60_000,
+    attachmentMaxBytes: 10 * 1024 * 1024
+  },
+  threads: {
+    activeByRecentBotParticipation: true
+  },
+  tools: {
+    enabled: true,
+    autoInstall: true,
+    reactions: true,
+    attachFiles: true,
+    fetchHistory: true,
+    followUpMessages: true,
+    createThread: false,
+    editDeleteOwn: false,
+    postOtherChannels: false,
+    pin: false
+  },
+  streaming: {
+    updateInterval: Duration.millis(500),
+    placeholderText: null,
+    showToolStatus: true,
+    changedFilesSummary: true
+  },
+  concurrency: {
+    strategy: "queue",
+    lockScope: "discord-scope",
+    globalMaxActiveTurns: null
+  },
+  guards: {
+    ignoreBots: true,
+    stripMassMentions: true,
+    redactSecretsInErrors: true,
+    maxTurn: null
+  }
+}
+
+const isRecord = (value: unknown): value is Readonly<Record<string, unknown>> =>
+  typeof value === "object" && value !== null && !Array.isArray(value)
+
+const decodeRawConfig = (value: unknown): Effect.Effect<Readonly<Record<string, unknown>>, ConfigError> =>
+  Schema.decodeUnknownEffect(RawConfigSchema)(value).pipe(
+    Effect.map((decoded) => decoded),
+    Effect.mapError(() => new ConfigError({ message: "Config file failed schema validation" }))
+  )
+
+const readRecord = (source: Readonly<Record<string, unknown>>, key: string): Readonly<Record<string, unknown>> => {
+  const value = source[key]
+  return isRecord(value) ? value : {}
+}
+
+const readNumber = (source: Readonly<Record<string, unknown>>, key: string, fallback: number): number => {
+  const value = source[key]
+  return typeof value === "number" && Number.isFinite(value) ? value : fallback
+}
+
+const readBoolean = (source: Readonly<Record<string, unknown>>, key: string, fallback: boolean): boolean => {
+  const value = source[key]
+  return typeof value === "boolean" ? value : fallback
+}
+
+const readNullableString = (source: Readonly<Record<string, unknown>>, key: string, fallback: string | null): string | null => {
+  const value = source[key]
+  if (value === null) return null
+  return typeof value === "string" ? value : fallback
+}
+
+const readNullableNumber = (source: Readonly<Record<string, unknown>>, key: string, fallback: number | null): number | null => {
+  const value = source[key]
+  if (value === null) return null
+  return typeof value === "number" && Number.isFinite(value) ? value : fallback
+}
+
+const readConcurrencyStrategy = (source: Readonly<Record<string, unknown>>): "queue" | "burst" => {
+  const value = source.strategy
+  return value === "queue" || value === "burst" ? value : defaultConfig.concurrency.strategy
+}
+
+const optionalEnv = (value: string | undefined): string | undefined => {
+  if (value === undefined) return undefined
+  const trimmed = value.trim()
+  return trimmed === "" ? undefined : trimmed
+}
+
+const parsePort = (value: string | undefined, fallback: number, name: string): Effect.Effect<number, ConfigError> => {
+  if (value === undefined || value.trim() === "") return Effect.succeed(fallback)
+  const parsed = Number(value)
+  if (Number.isInteger(parsed) && parsed > 0 && parsed <= 65_535) return Effect.succeed(parsed)
+  return Effect.fail(new ConfigError({ message: `${name} must be a TCP port` }))
+}
+
+const parseConfigText = (text: string | undefined): Effect.Effect<Readonly<Record<string, unknown>>, ConfigError> => {
+  if (text === undefined || text.trim() === "") return Effect.succeed({})
+  return Effect.try({
+    try: () => {
+      const errors: Array<ParseError> = []
+      const parsed: unknown = parse(text, errors)
+      if (errors.length > 0) throw new Error("Invalid JSONC")
+      if (!isRecord(parsed)) return {}
+      return parsed
+    },
+    catch: () => new ConfigError({ message: "Config file must be valid JSONC" })
+  }).pipe(Effect.flatMap(decodeRawConfig))
+}
+
+const isMissingFile = (cause: unknown): boolean => typeof cause === "object" && cause !== null && "code" in cause && cause.code === "ENOENT"
+
+const readOptionalConfigFile = (path: string): Effect.Effect<string | undefined, ConfigError> =>
+  Effect.tryPromise({
+    try: async () => {
+      try {
+        return await readFile(path, "utf8")
+      } catch (cause) {
+        if (isMissingFile(cause)) return undefined
+        throw cause
+      }
+    },
+    catch: () => new ConfigError({ message: "Unable to read config file" })
+  })
+
+export const loadConfigFromSources = Effect.fn("loadConfigFromSources")(function* (sources: ConfigSources) {
+  const file = yield* parseConfigText(sources.configText)
+  const token = sources.env.DISCORD_TOKEN
+  if (token === undefined || token.trim() === "") {
+    return yield* Effect.fail(new ConfigError({ message: "DISCORD_TOKEN is required" }))
+  }
+
+  const opencodePort = yield* parsePort(sources.env.OPENCODE_PORT, defaultConfig.opencode.port, "OPENCODE_PORT")
+  const bridgePort = yield* parsePort(sources.env.DISCORD_BRIDGE_PORT, defaultConfig.bridge.port, "DISCORD_BRIDGE_PORT")
+  const tools = readRecord(file, "tools")
+  const streaming = readRecord(file, "streaming")
+  const threads = readRecord(file, "threads")
+  const concurrency = readRecord(file, "concurrency")
+  const guards = readRecord(file, "guards")
+
+  const applicationId = optionalEnv(sources.env.DISCORD_APPLICATION_ID)
+  const publicKey = optionalEnv(sources.env.DISCORD_PUBLIC_KEY)
+  const guildId = optionalEnv(sources.env.DISCORD_GUILD_ID)
+  const model = optionalEnv(sources.env.OPENCODE_MODEL)
+  const agent = optionalEnv(sources.env.OPENCODE_AGENT)
+  const projectDir = optionalEnv(sources.env.OPENCODE_PROJECT_DIR) ?? sources.cwd
+  const maxTurnMs = readNullableNumber(guards, "maxTurnMs", null)
+
+  return {
+    discordToken: Redacted.make(token),
+    discord: {
+      ...(applicationId === undefined ? {} : { applicationId }),
+      ...(publicKey === undefined ? {} : { publicKey }),
+      ...(guildId === undefined ? {} : { guildId })
+    },
+    opencode: {
+      port: opencodePort,
+      baseUrl: `http://127.0.0.1:${opencodePort}`,
+      projectDir,
+      ...(model === undefined ? {} : { model }),
+      ...(agent === undefined ? {} : { agent })
+    },
+    bridge: {
+      host: defaultConfig.bridge.host,
+      port: bridgePort
+    },
+    context: {
+      messages: readNumber(file, "contextMessages", defaultConfig.context.messages),
+      maxChars: readNumber(file, "contextMaxChars", defaultConfig.context.maxChars),
+      attachmentMaxBytes: readNumber(file, "attachmentMaxBytes", defaultConfig.context.attachmentMaxBytes)
+    },
+    threads: {
+      activeByRecentBotParticipation: readBoolean(
+        threads,
+        "activeByRecentBotParticipation",
+        defaultConfig.threads.activeByRecentBotParticipation
+      )
+    },
+    tools: {
+      enabled: readBoolean(tools, "enabled", defaultConfig.tools.enabled),
+      autoInstall: readBoolean(tools, "autoInstall", defaultConfig.tools.autoInstall),
+      reactions: readBoolean(tools, "reactions", defaultConfig.tools.reactions),
+      attachFiles: readBoolean(tools, "attachFiles", defaultConfig.tools.attachFiles),
+      fetchHistory: readBoolean(tools, "fetchHistory", defaultConfig.tools.fetchHistory),
+      followUpMessages: readBoolean(tools, "followUpMessages", defaultConfig.tools.followUpMessages),
+      createThread: readBoolean(tools, "createThread", defaultConfig.tools.createThread),
+      editDeleteOwn: readBoolean(tools, "editDeleteOwn", defaultConfig.tools.editDeleteOwn),
+      postOtherChannels: readBoolean(tools, "postOtherChannels", defaultConfig.tools.postOtherChannels),
+      pin: readBoolean(tools, "pin", defaultConfig.tools.pin)
+    },
+    streaming: {
+      updateInterval: Duration.millis(readNumber(streaming, "updateIntervalMs", 500)),
+      placeholderText: readNullableString(streaming, "placeholderText", defaultConfig.streaming.placeholderText),
+      showToolStatus: readBoolean(streaming, "showToolStatus", defaultConfig.streaming.showToolStatus),
+      changedFilesSummary: readBoolean(streaming, "changedFilesSummary", defaultConfig.streaming.changedFilesSummary)
+    },
+    concurrency: {
+      strategy: readConcurrencyStrategy(concurrency),
+      lockScope: defaultConfig.concurrency.lockScope,
+      globalMaxActiveTurns: readNullableNumber(concurrency, "globalMaxActiveTurns", defaultConfig.concurrency.globalMaxActiveTurns)
+    },
+    guards: {
+      ignoreBots: readBoolean(guards, "ignoreBots", defaultConfig.guards.ignoreBots),
+      stripMassMentions: readBoolean(guards, "stripMassMentions", defaultConfig.guards.stripMassMentions),
+      redactSecretsInErrors: readBoolean(guards, "redactSecretsInErrors", defaultConfig.guards.redactSecretsInErrors),
+      maxTurn: maxTurnMs === null ? null : Duration.millis(maxTurnMs)
+    }
+  } satisfies RuntimeConfig
+})
+
+export const loadConfig = Effect.fn("loadConfig")(function* (options: LoadConfigOptions) {
+  const configText = yield* readOptionalConfigFile(options.configPath ?? join(options.cwd, ".opencode-discord.jsonc"))
+  return yield* loadConfigFromSources({ cwd: options.cwd, env: options.env, configText })
+})

package/src/ConfigSchema.ts

@@ -0,0 +1,46 @@
+import { Schema } from "effect"
+
+const PositiveInt = Schema.Number.check(Schema.isInt(), Schema.isGreaterThan(0))
+const OptionalBoolean = Schema.optional(Schema.Boolean)
+const RawToolsSchema = Schema.Struct({
+  enabled: OptionalBoolean,
+  autoInstall: OptionalBoolean,
+  reactions: OptionalBoolean,
+  attachFiles: OptionalBoolean,
+  fetchHistory: OptionalBoolean,
+  followUpMessages: OptionalBoolean,
+  createThread: OptionalBoolean,
+  editDeleteOwn: OptionalBoolean,
+  postOtherChannels: OptionalBoolean,
+  pin: OptionalBoolean
+})
+
+export const RawConfigSchema = Schema.Struct({
+  contextMessages: Schema.optional(PositiveInt),
+  contextMaxChars: Schema.optional(PositiveInt),
+  attachmentMaxBytes: Schema.optional(PositiveInt),
+  threads: Schema.optional(Schema.Struct({ activeByRecentBotParticipation: OptionalBoolean })),
+  tools: Schema.optional(RawToolsSchema),
+  streaming: Schema.optional(
+    Schema.Struct({
+      updateIntervalMs: Schema.optional(PositiveInt),
+      placeholderText: Schema.optional(Schema.NullOr(Schema.String)),
+      showToolStatus: OptionalBoolean,
+      changedFilesSummary: OptionalBoolean
+    })
+  ),
+  concurrency: Schema.optional(
+    Schema.Struct({
+      strategy: Schema.optional(Schema.Union([Schema.Literal("queue"), Schema.Literal("burst")])),
+      globalMaxActiveTurns: Schema.optional(Schema.NullOr(PositiveInt))
+    })
+  ),
+  guards: Schema.optional(
+    Schema.Struct({
+      ignoreBots: OptionalBoolean,
+      stripMassMentions: OptionalBoolean,
+      redactSecretsInErrors: OptionalBoolean,
+      maxTurnMs: Schema.optional(Schema.NullOr(PositiveInt))
+    })
+  )
+})

package/src/ConfigTypes.ts

@@ -0,0 +1,11 @@
+export type ConfigSources = {
+  readonly cwd: string
+  readonly env: Readonly<Record<string, string | undefined>>
+  readonly configText?: string | undefined
+}
+
+export type LoadConfigOptions = {
+  readonly cwd: string
+  readonly env: Readonly<Record<string, string | undefined>>
+  readonly configPath?: string
+}

package/src/Discord/ChatSdkDiscord.test.ts

@@ -0,0 +1,257 @@
+import { describe, expect, test } from "bun:test"
+import { mkdtemp, rm, writeFile } from "node:fs/promises"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
+import type { DiscordThreadId } from "@chat-adapter/discord"
+import type { AdapterPostableMessage, ChannelInfo, FetchResult, RawMessage } from "chat"
+import { Message, parseMarkdown } from "chat"
+import { Duration, Effect } from "effect"
+import type { DiscordScope } from "../Schema.ts"
+import { makeChatSdkDiscord } from "./ChatSdkDiscord.ts"
+import { DiscordError } from "./DiscordPort.ts"
+
+const scope: DiscordScope = { guildId: "g1", channelId: "c1", threadId: "t1" }
+
+class FakeDiscordAdapter {
+  readonly calls: Array<readonly [string, unknown]> = []
+
+  encodeThreadId(input: DiscordThreadId): string {
+    this.calls.push(["encodeThreadId", input])
+    return input.threadId === undefined
+      ? `discord:${input.guildId}:${input.channelId}`
+      : `discord:${input.guildId}:${input.channelId}:${input.threadId}`
+  }
+
+  postMessage(threadId: string, message: AdapterPostableMessage): Promise<RawMessage<unknown>> {
+    this.calls.push(["postMessage", { threadId, message }])
+    return Promise.resolve({ id: "posted-1", threadId, raw: {} })
+  }
+
+  editMessage(threadId: string, messageId: string, message: AdapterPostableMessage): Promise<RawMessage<unknown>> {
+    this.calls.push(["editMessage", { threadId, messageId, message }])
+    return Promise.resolve({ id: messageId, threadId, raw: {} })
+  }
+
+  deleteMessage(threadId: string, messageId: string): Promise<void> {
+    this.calls.push(["deleteMessage", { threadId, messageId }])
+    return Promise.resolve()
+  }
+
+  postChannelMessage(channelId: string, message: AdapterPostableMessage): Promise<RawMessage<unknown>> {
+    this.calls.push(["postChannelMessage", { channelId, message }])
+    return Promise.resolve({ id: "posted-channel-1", threadId: channelId, raw: {} })
+  }
+
+  fetchChannelInfo(channelId: string): Promise<ChannelInfo> {
+    this.calls.push(["fetchChannelInfo", { channelId }])
+    return Promise.resolve({ id: channelId, isDM: false, metadata: { raw: { guild_id: "g1" } } })
+  }
+
+  startTyping(threadId: string): Promise<void> {
+    this.calls.push(["startTyping", { threadId }])
+    return Promise.resolve()
+  }
+
+  addReaction(threadId: string, messageId: string, emoji: string): Promise<void> {
+    this.calls.push(["addReaction", { threadId, messageId, emoji }])
+    return Promise.resolve()
+  }
+
+  removeReaction(threadId: string, messageId: string, emoji: string): Promise<void> {
+    this.calls.push(["removeReaction", { threadId, messageId, emoji }])
+    return Promise.resolve()
+  }
+
+  fetchMessages(threadId: string): Promise<FetchResult<unknown>> {
+    this.calls.push(["fetchMessages", { threadId }])
+    return Promise.resolve({
+      messages: [
+        new Message({
+          id: "m1",
+          threadId,
+          text: "hello <@999>",
+          formatted: parseMarkdown("hello <@999>"),
+          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: [{ type: "file", name: "notes.txt", mimeType: "text/plain", size: 42, url: "https://example.test/notes.txt" }]
+        })
+      ]
+    })
+  }
+}
+
+describe("makeChatSdkDiscord", () => {
+  test("routes Discord port operations through chat-sdk adapter primitives", async () => {
+    const adapter = new FakeDiscordAdapter()
+    const discord = makeChatSdkDiscord(adapter)
+
+    const context = await Effect.runPromise(discord.fetchContext(scope, 30))
+    const history = await Effect.runPromise(discord.fetchHistory(scope, 2))
+    const posted = await Effect.runPromise(discord.postMessage(scope, "reply"))
+    await Effect.runPromise(discord.editMessage(scope, posted.id, "edited"))
+    await Effect.runPromise(discord.sendTyping(scope))
+    await Effect.runPromise(discord.addReaction(scope, "m1", "rocket"))
+    await Effect.runPromise(discord.removeReaction(scope, "m1", "rocket"))
+    const directory = await mkdtemp(join(tmpdir(), "ocdb-chat-"))
+
+    try {
+      const path = join(directory, "upload.txt")
+      await writeFile(path, "uploaded")
+      expect(await Effect.runPromise(discord.attachFile(scope, path))).toEqual({ path: "posted-1" })
+    } finally {
+      await rm(directory, { recursive: true, force: true })
+    }
+
+    expect(context).toEqual([
+      {
+        id: "m1",
+        guildId: "g1",
+        channelId: "c1",
+        threadId: "t1",
+        author: { id: "u1", displayName: "Alice", nickname: "alice", isBot: false },
+        content: "hello <@999>",
+        timestamp: "2026-06-05T14:03:00.000Z",
+        mentions: ["999"],
+        roleMentions: [],
+        everyoneMention: false,
+        hereMention: false,
+        attachments: [{ id: "m1-0", filename: "notes.txt", contentType: "text/plain", size: 42, url: "https://example.test/notes.txt" }],
+        reactions: [],
+        channelType: "guild"
+      }
+    ])
+    expect(history).toEqual(context)
+    expect(adapter.calls.map((item) => item[0])).toEqual([
+      "encodeThreadId",
+      "fetchMessages",
+      "encodeThreadId",
+      "fetchMessages",
+      "encodeThreadId",
+      "postMessage",
+      "encodeThreadId",
+      "editMessage",
+      "encodeThreadId",
+      "startTyping",
+      "encodeThreadId",
+      "addReaction",
+      "encodeThreadId",
+      "removeReaction",
+      "encodeThreadId",
+      "postMessage"
+    ])
+  })
+
+  test("routes channel posts, deletes, and raw REST adapter gaps", async () => {
+    const adapter = new FakeDiscordAdapter()
+    const requests: Array<readonly [string, RequestInit]> = []
+    const originalFetch = globalThis.fetch
+    const fakeFetch: typeof fetch = Object.assign(
+      (input: URL | RequestInfo, init?: BunFetchRequestInit | RequestInit) => {
+        requests.push([String(input), init ?? {}])
+        return Promise.resolve(
+          new Response(input.toString().includes("/threads") ? JSON.stringify({ id: "thread-1" }) : undefined, {
+            status: input.toString().includes("/threads") ? 200 : 204,
+            headers: { "content-type": "application/json" }
+          })
+        )
+      },
+      { preconnect: originalFetch.preconnect }
+    )
+    globalThis.fetch = fakeFetch
+
+    try {
+      const discord = makeChatSdkDiscord(adapter, { botToken: "token", apiUrl: "https://discord.test/api" })
+
+      await Effect.runPromise(discord.deleteMessage(scope, "m1"))
+      expect(await Effect.runPromise(discord.postChannelMessage("g1", "c2", "hello"))).toEqual({ id: "posted-channel-1" })
+      expect(await Effect.runPromise(discord.createThread(scope, "work"))).toEqual({ id: "thread-1" })
+      await Effect.runPromise(discord.pinMessage(scope, "m1"))
+      await Effect.runPromise(discord.unpinMessage(scope, "m1"))
+    } finally {
+      globalThis.fetch = originalFetch
+    }
+
+    expect(adapter.calls.map((item) => item[0])).toEqual([
+      "encodeThreadId",
+      "deleteMessage",
+      "encodeThreadId",
+      "fetchChannelInfo",
+      "postChannelMessage"
+    ])
+    expect(requests.map((request) => [request[0], request[1].method])).toEqual([
+      ["https://discord.test/api/channels/c1/threads", "POST"],
+      ["https://discord.test/api/channels/t1/pins/m1", "PUT"],
+      ["https://discord.test/api/channels/t1/pins/m1", "DELETE"]
+    ])
+  })
+
+  test("fails raw REST operations when no raw Discord client is configured", async () => {
+    const discord = makeChatSdkDiscord(new FakeDiscordAdapter())
+
+    await expect(Effect.runPromise(discord.createThread(scope, "work"))).rejects.toMatchObject({
+      _tag: "DiscordError",
+      message: "Discord adapter does not expose this operation"
+    })
+  })
+
+  test("preserves chat-sdk adapter retry metadata", async () => {
+    const adapter = new FakeDiscordAdapter()
+    adapter.postMessage = () => Promise.reject(Object.assign(new Error("limited"), { retryAfterMs: 123 }))
+    const discord = makeChatSdkDiscord(adapter)
+    let error: unknown
+
+    try {
+      await Effect.runPromise(discord.postMessage(scope, "hello"))
+    } catch (cause) {
+      error = cause
+    }
+
+    if (!(error instanceof DiscordError)) throw new Error("expected DiscordError")
+    if (error.retryAfter === undefined) throw new Error("expected retryAfter")
+    expect(error.message).toBe("limited")
+    expect(Duration.toMillis(error.retryAfter)).toBe(123)
+  })
+
+  test("rejects DM channel info before cross-channel posting", async () => {
+    const adapter = new FakeDiscordAdapter()
+    adapter.fetchChannelInfo = (channelId: string) => {
+      adapter.calls.push(["fetchChannelInfo", { channelId }])
+      return Promise.resolve({ id: channelId, isDM: true, metadata: {} })
+    }
+    const discord = makeChatSdkDiscord(adapter)
+
+    await expect(Effect.runPromise(discord.postChannelMessage("g1", "dm1", "hello"))).rejects.toMatchObject({
+      _tag: "DiscordError",
+      message: "Discord DMs are not supported"
+    })
+    expect(adapter.calls.map((item) => item[0])).toEqual(["encodeThreadId", "fetchChannelInfo"])
+  })
+
+  test("preserves raw Discord REST retry-after metadata", async () => {
+    const originalFetch = globalThis.fetch
+    const fakeFetch: typeof fetch = Object.assign(
+      () => Promise.resolve(new Response("limited", { status: 429, headers: { "retry-after": "2" } })),
+      { preconnect: originalFetch.preconnect }
+    )
+    globalThis.fetch = fakeFetch
+
+    try {
+      const discord = makeChatSdkDiscord(new FakeDiscordAdapter(), { botToken: "token", apiUrl: "https://discord.test/api" })
+      let error: unknown
+
+      try {
+        await Effect.runPromise(discord.createThread(scope, "work"))
+      } catch (cause) {
+        error = cause
+      }
+
+      if (!(error instanceof DiscordError)) throw new Error("expected DiscordError")
+      if (error.retryAfter === undefined) throw new Error("expected retryAfter")
+      expect(error.message).toBe("Discord REST 429: limited")
+      expect(Duration.toMillis(error.retryAfter)).toBe(2000)
+    } finally {
+      globalThis.fetch = originalFetch
+    }
+  })
+})