opencode-discord-bot 0.0.11 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-discord-bot",
-  "version": "0.0.11",
+  "version": "0.2.0",
   "description": "Discord bot bridge for a self-hosted opencode instance",
   "type": "module",
   "main": "src/Main.ts",

package/src/Bridge/ToolControl.test.ts

@@ -104,7 +104,7 @@ describe("handleToolRequest", () => {
 })
 
 describe("handleToolRequest action dispatch", () => {
-  test("dispatches reactions, history, and safe attachments", async () => {
+  test("dispatches reactions, search, and safe attachments", async () => {
     const projectDir = await mkdtemp(join(tmpdir(), "ocdb-tool-"))
     await mkdir(join(projectDir, "out"), { recursive: true })
     await writeFile(join(projectDir, "out", "report.txt"), "report")
@@ -137,9 +137,9 @@ describe("handleToolRequest action dispatch", () => {
           discord
         )
       )
-      const history = await Effect.runPromise(
+      const search = await Effect.runPromise(
         handleToolRequest(
-          { action: "fetchHistory", target: { guildId: "g1", channelId: "c1" }, args: { limit: 1 } },
+          { action: "searchMessages", target: { guildId: "g1" }, args: { query: "hi", limit: 1 } },
           defaultConfig,
           projectDir,
           discord
@@ -156,7 +156,15 @@ describe("handleToolRequest action dispatch", () => {
       const attachmentRealpath = await realpath(join(projectDir, "out", "report.txt"))
 
       expect(add).toEqual({ ok: true, result: { reacted: true } })
-      expect(history.ok).toBe(true)
+      expect(search).toEqual({
+        ok: true,
+        result: {
+          totalResults: 1,
+          offset: 0,
+          hasMore: false,
+          messages: discord.context
+        }
+      })
       expect(attach).toEqual({ ok: true, result: { path: attachmentRealpath } })
       expect(discord.reactions.map((item) => item.op)).toEqual(["add"])
       expect(discord.attachments).toEqual([{ scope: { guildId: "g1", channelId: "c1" }, path: attachmentRealpath }])
@@ -199,6 +207,21 @@ describe("handleToolRequest action dispatch", () => {
     expect(response).toEqual({ ok: false, error: "Discord target is outside the active turn scope" })
   })
 
+  test("allows search across the active turn guild", async () => {
+    const discord = makeMemoryDiscord({ context: [] })
+    const response = await Effect.runPromise(
+      handleToolRequest(
+        { action: "searchMessages", target: { guildId: "g1" }, args: { query: "from:<@u1>" } },
+        defaultConfig,
+        "/repo",
+        discord,
+        { allowedScopes: [{ guildId: "g1", channelId: "c1" }] }
+      )
+    )
+
+    expect(response).toEqual({ ok: true, result: { totalResults: 0, offset: 0, hasMore: false, messages: [] } })
+  })
+
   test("returns validation errors for malformed or unsupported requests", async () => {
     const disabled = await Effect.runPromise(
       handleToolRequest(
@@ -232,10 +255,14 @@ describe("handleToolRequest action dispatch", () => {
         makeMemoryDiscord()
       )
     )
+    const missingQuery = await Effect.runPromise(
+      handleToolRequest({ action: "searchMessages", target: { guildId: "g1" }, args: {} }, defaultConfig, "/repo", makeMemoryDiscord())
+    )
 
     expect(disabled).toEqual({ ok: false, error: "Discord bridge tools are disabled" })
     expect(unknown).toEqual({ ok: false, error: "Unknown action unknown" })
     expect(missingReactionFields).toEqual({ ok: false, error: "messageId and emoji are required" })
     expect(missingPath).toEqual({ ok: false, error: "path is required" })
+    expect(missingQuery).toEqual({ ok: false, error: "query is required" })
   })
 })

package/src/Bridge/ToolControl.ts

@@ -3,6 +3,7 @@ import { isAbsolute, resolve, sep } from "node:path"
 import { Effect } from "effect"
 import type { RuntimeConfig, ToolConfig } from "../Config.ts"
 import type { DiscordService } from "../Discord/DiscordPort.ts"
+import { hasDiscordSearchCriteria, parseDiscordSearchQuery } from "../Discord/SearchQuery.ts"
 import type { DiscordScope, ToolRequest, ToolResponse } from "../Schema.ts"
 
 type ToolRequestOptions = {
@@ -15,8 +16,8 @@ const actionFlag = (action: string): keyof ToolConfig | undefined => {
       return "reactions"
     case "attachFile":
       return "attachFiles"
-    case "fetchHistory":
-      return "fetchHistory"
+    case "searchMessages":
+      return "searchMessages"
     case "createThread":
       return "createThread"
     default:
@@ -24,14 +25,15 @@ const actionFlag = (action: string): keyof ToolConfig | undefined => {
   }
 }
 
-const scopeFromRequest = (request: ToolRequest): DiscordScope | string => {
+const scopeFromRequest = (request: ToolRequest, requireChannel: boolean): DiscordScope | string => {
   const { guildId, channelId, threadId } = request.target
-  if (guildId === undefined || channelId === undefined) return "Discord target must include guildId and channelId"
+  if (guildId === undefined) return "Discord target must include guildId"
+  if (requireChannel && channelId === undefined) return "Discord target must include guildId and channelId"
   const values = [guildId, channelId, threadId]
   if (values.some((value) => value?.toLowerCase() === "@me" || value?.toLowerCase() === "dm")) {
     return "Discord DMs are not supported"
   }
-  return { guildId, channelId, ...(threadId === undefined ? {} : { threadId }) }
+  return { guildId, channelId: channelId ?? "", ...(threadId === undefined ? {} : { threadId }) }
 }
 
 const scopeKey = (scope: DiscordScope): string => `${scope.guildId}:${scope.channelId}:${scope.threadId ?? ""}`
@@ -39,11 +41,21 @@ const scopeKey = (scope: DiscordScope): string => `${scope.guildId}:${scope.chan
 const isAllowedScope = (scope: DiscordScope, allowedScopes: ReadonlyArray<DiscordScope> | undefined): boolean =>
   allowedScopes === undefined || allowedScopes.some((allowed) => scopeKey(allowed) === scopeKey(scope))
 
+const isAllowedGuild = (scope: DiscordScope, allowedScopes: ReadonlyArray<DiscordScope> | undefined): boolean =>
+  allowedScopes === undefined || allowedScopes.some((allowed) => allowed.guildId === scope.guildId)
+
 const stringArg = (request: ToolRequest, key: string): string | undefined => {
   const value = request.args[key]
   return typeof value === "string" ? value : undefined
 }
 
+const integerArg = (request: ToolRequest, key: string): number | undefined => {
+  const value = request.args[key]
+  return typeof value === "number" && Number.isInteger(value) ? value : undefined
+}
+
+const clamp = (value: number, min: number, max: number): number => Math.max(min, Math.min(max, value))
+
 const attachmentPath = Effect.fn("attachmentPath")(function* (projectDir: string, input: string, maxBytes: number) {
   if (isAbsolute(input) || input.includes(".."))
     return { ok: false, error: "Attachment path must stay inside the project directory" } satisfies ToolResponse
@@ -69,14 +81,17 @@ const addReaction = Effect.fn("toolAddReaction")(function* (request: ToolRequest
   return { ok: true, result: { reacted: true } } satisfies ToolResponse
 })
 
-const fetchHistory = Effect.fn("toolFetchHistory")(function* (
-  request: ToolRequest,
-  scope: DiscordScope,
-  config: RuntimeConfig,
-  discord: DiscordService
-) {
-  const limit = typeof request.args.limit === "number" ? request.args.limit : config.context.messages
-  const result = yield* discord.fetchHistory(scope, limit)
+const searchMessages = Effect.fn("toolSearchMessages")(function* (request: ToolRequest, scope: DiscordScope, discord: DiscordService) {
+  const queryText = stringArg(request, "query")
+  if (queryText === undefined || queryText.trim() === "") return { ok: false, error: "query is required" } satisfies ToolResponse
+  const parsed = parseDiscordSearchQuery(queryText)
+  if (!parsed.ok) return { ok: false, error: parsed.error } satisfies ToolResponse
+  if (!hasDiscordSearchCriteria(parsed.query)) {
+    return { ok: false, error: "query must contain at least one Discord search criterion" } satisfies ToolResponse
+  }
+  const limit = clamp(integerArg(request, "limit") ?? 25, 1, 25)
+  const offset = clamp(integerArg(request, "offset") ?? 0, 0, 9975)
+  const result = yield* discord.searchMessages(scope, parsed.query, { limit, offset })
   return { ok: true, result } satisfies ToolResponse
 })
 
@@ -114,17 +129,18 @@ export const handleToolRequest = Effect.fn("handleToolRequest")(function* (
   if (flag === undefined) return { ok: false, error: `Unknown action ${request.action}` } satisfies ToolResponse
   if (!config.tools[flag]) return disabled(request.action)
 
-  const scope = scopeFromRequest(request)
+  const isSearch = request.action === "searchMessages"
+  const scope = scopeFromRequest(request, !isSearch)
   if (typeof scope === "string") return { ok: false, error: scope } satisfies ToolResponse
-  if (!isAllowedScope(scope, options.allowedScopes)) {
+  if (isSearch ? !isAllowedGuild(scope, options.allowedScopes) : !isAllowedScope(scope, options.allowedScopes)) {
     return { ok: false, error: "Discord target is outside the active turn scope" } satisfies ToolResponse
   }
 
   switch (request.action) {
     case "addReaction":
       return yield* addReaction(request, scope, discord)
-    case "fetchHistory":
-      return yield* fetchHistory(request, scope, config, discord)
+    case "searchMessages":
+      return yield* searchMessages(request, scope, discord)
     case "attachFile":
       return yield* attachFile(request, scope, config, projectDir, discord)
     case "createThread":

package/src/Config.ts

@@ -16,7 +16,7 @@ export type ToolConfig = {
   readonly autoInstall: boolean
   readonly reactions: boolean
   readonly attachFiles: boolean
-  readonly fetchHistory: boolean
+  readonly searchMessages: boolean
   readonly createThread: boolean
 }
 
@@ -91,7 +91,7 @@ export const defaultConfig: RuntimeConfig = {
     autoInstall: true,
     reactions: true,
     attachFiles: true,
-    fetchHistory: true,
+    searchMessages: true,
     createThread: false
   },
   streaming: {
@@ -254,7 +254,7 @@ export const loadConfigFromSources = Effect.fn("loadConfigFromSources")(function
       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),
+      searchMessages: readBoolean(tools, "searchMessages", defaultConfig.tools.searchMessages),
       createThread: readBoolean(tools, "createThread", defaultConfig.tools.createThread)
     },
     streaming: {

package/src/ConfigSchema.ts

@@ -7,7 +7,7 @@ const RawToolsSchema = Schema.Struct({
   autoInstall: OptionalBoolean,
   reactions: OptionalBoolean,
   attachFiles: OptionalBoolean,
-  fetchHistory: OptionalBoolean,
+  searchMessages: OptionalBoolean,
   createThread: OptionalBoolean
 })
 

package/src/Discord/ChatSdkDiscord.test.ts

@@ -72,7 +72,6 @@ describe("makeChatSdkDiscord", () => {
     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))
@@ -105,10 +104,7 @@ describe("makeChatSdkDiscord", () => {
         channelType: "guild"
       }
     ])
-    expect(history).toEqual(context)
     expect(adapter.calls.map((item) => item[0])).toEqual([
-      "encodeThreadId",
-      "fetchMessages",
       "encodeThreadId",
       "fetchMessages",
       "encodeThreadId",
@@ -161,10 +157,8 @@ describe("makeChatSdkDiscord REST operations", () => {
       const discord = makeChatSdkDiscord(adapter, { botToken: "token", apiUrl: "https://discord.test/api" })
 
       const context = await Effect.runPromise(discord.fetchContext(scope, 30))
-      const history = await Effect.runPromise(discord.fetchHistory(scope, 30))
 
       expect(context[0]?.author).toEqual({ id: "u1", displayName: "Alice", nickname: "Ali the Great", isBot: false })
-      expect(history[0]?.author).toEqual({ id: "u1", displayName: "Alice", nickname: "Ali the Great", isBot: false })
     } finally {
       globalThis.fetch = originalFetch
     }

package/src/Discord/ChatSdkDiscord.ts

@@ -3,8 +3,10 @@ import { basename } from "node:path"
 import { createDiscordAdapter, type DiscordThreadId } from "@chat-adapter/discord"
 import type { AdapterPostableMessage, FetchOptions, FetchResult, Message, PostableRaw, RawMessage } from "chat"
 import { Duration, Effect } from "effect"
-import type { DiscordAttachment, DiscordMessage, DiscordScope } from "../Schema.ts"
+import type { DiscordAttachment, DiscordMessage, DiscordReaction, DiscordScope } from "../Schema.ts"
 import { DiscordError, type DiscordService } from "./DiscordPort.ts"
+import { type RawDiscordOptions, rawDiscord, rawDiscordRequest } from "./DiscordRest.ts"
+import { searchDiscordMessages } from "./DiscordSearchRest.ts"
 
 type ChatDiscordAdapter = {
   readonly encodeThreadId: (input: DiscordThreadId) => string
@@ -52,6 +54,23 @@ const attachments = (message: Message<unknown>): ReadonlyArray<DiscordAttachment
     url: item.url ?? ""
   }))
 
+const reactionEmoji = (value: unknown): string => {
+  if (!isRecord(value)) return "unknown"
+  const name = typeof value.name === "string" && value.name.length > 0 ? value.name : undefined
+  const id = typeof value.id === "string" && value.id.length > 0 ? value.id : undefined
+  if (id !== undefined && name !== undefined) return `${value.animated === true ? "a:" : ""}${name}:${id}`
+  return name ?? id ?? "unknown"
+}
+
+const reactions = (message: Message<unknown>): ReadonlyArray<DiscordReaction> => {
+  if (!isRecord(message.raw)) return []
+  const rawReactions: ReadonlyArray<unknown> = Array.isArray(message.raw.reactions) ? message.raw.reactions : []
+  return rawReactions.flatMap((item) => {
+    if (!isRecord(item) || typeof item.count !== "number" || !Number.isFinite(item.count) || item.count < 0) return []
+    return [{ emoji: reactionEmoji(item.emoji), count: item.count }]
+  })
+}
+
 const fromChatMessage = (scope: DiscordScope, message: Message<unknown>, nickname?: string | undefined): DiscordMessage => ({
   id: message.id,
   guildId: scope.guildId,
@@ -70,7 +89,7 @@ const fromChatMessage = (scope: DiscordScope, message: Message<unknown>, nicknam
   everyoneMention: message.text.includes("@everyone"),
   hereMention: message.text.includes("@here"),
   attachments: attachments(message),
-  reactions: [],
+  reactions: reactions(message),
   channelType: "guild"
 })
 
@@ -100,41 +119,6 @@ const tryAdapter = <A>(operation: () => Promise<A>): Effect.Effect<A, DiscordErr
           })
   })
 
-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
-  readonly nicknameCacheTtlMs?: number | undefined
-}
-
-const rawDiscordRequest = async (options: RawDiscordOptions | undefined, path: string, init: RequestInit): Promise<unknown> => {
-  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()
-}
-
-const rawDiscord = (options: RawDiscordOptions | undefined, path: string, init: RequestInit): Effect.Effect<unknown, DiscordError> =>
-  tryAdapter(() => rawDiscordRequest(options, path, init))
-
 const memberNickname = (data: unknown): string | undefined => {
   if (!isRecord(data)) return undefined
   const nick = data.nick
@@ -207,7 +191,7 @@ export const makeChatSdkDiscord = (adapter: ChatDiscordAdapter, raw: RawDiscordO
 
   return {
     fetchContext: fetchMessages,
-    fetchHistory: fetchMessages,
+    searchMessages: (scope, query, paging) => tryAdapter(() => searchDiscordMessages(raw, scope, query, paging, resolveNickname)),
     sendTyping: (scope) => tryAdapter(() => adapter.startTyping(threadIdFromScope(adapter, scope))).pipe(Effect.asVoid),
     postMessage: (scope, content) =>
       tryAdapter(async () => {

package/src/Discord/ChatSdkDiscordReactions.test.ts

@@ -0,0 +1,77 @@
+import { describe, expect, test } from "bun:test"
+import type { DiscordThreadId } from "@chat-adapter/discord"
+import type { AdapterPostableMessage, FetchOptions, FetchResult, RawMessage } from "chat"
+import { Message, parseMarkdown } from "chat"
+import { Effect } from "effect"
+import type { DiscordScope } from "../Schema.ts"
+import { makeChatSdkDiscord } from "./ChatSdkDiscord.ts"
+
+const scope: DiscordScope = { guildId: "g1", channelId: "c1" }
+
+const makeMessage = (threadId: string, raw: unknown): Message<unknown> =>
+  new Message({
+    id: "m1",
+    threadId,
+    text: "hello",
+    formatted: parseMarkdown("hello"),
+    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: []
+  })
+
+class ReactionAdapter {
+  encodeThreadId(input: DiscordThreadId): string {
+    return `discord:${input.guildId}:${input.channelId}`
+  }
+
+  fetchMessages(threadId: string, _options?: FetchOptions): Promise<FetchResult<unknown>> {
+    return Promise.resolve({
+      messages: [
+        makeMessage(threadId, {
+          reactions: [
+            { count: 3, emoji: { id: null, name: "\u{1F680}" } },
+            { count: 2, emoji: { id: "custom1", name: "party_blob", animated: false } },
+            { count: 1, emoji: { id: "anim1", name: "dance", animated: true } },
+            { count: "bad", emoji: { id: null, name: "ignored" } },
+            { count: -1, emoji: { id: null, name: "ignored" } }
+          ]
+        })
+      ]
+    })
+  }
+
+  postMessage(threadId: string, _message: AdapterPostableMessage): Promise<RawMessage<unknown>> {
+    return Promise.resolve({ id: "posted", raw: {}, threadId })
+  }
+
+  editMessage(threadId: string, messageId: string, _message: AdapterPostableMessage): Promise<RawMessage<unknown>> {
+    return Promise.resolve({ id: messageId, raw: {}, threadId })
+  }
+
+  deleteMessage(_threadId: string, _messageId: string): Promise<void> {
+    return Promise.resolve()
+  }
+
+  startTyping(_threadId: string, _status?: string): Promise<void> {
+    return Promise.resolve()
+  }
+
+  addReaction(_threadId: string, _messageId: string, _emoji: string): Promise<void> {
+    return Promise.resolve()
+  }
+}
+
+describe("makeChatSdkDiscord reactions", () => {
+  test("maps aggregate reactions from raw Discord messages", async () => {
+    const discord = makeChatSdkDiscord(new ReactionAdapter())
+
+    const context = await Effect.runPromise(discord.fetchContext(scope, 30))
+
+    expect(context[0]?.reactions).toEqual([
+      { emoji: "\u{1F680}", count: 3 },
+      { emoji: "party_blob:custom1", count: 2 },
+      { emoji: "a:dance:anim1", count: 1 }
+    ])
+  })
+})

package/src/Discord/ChatSdkDiscordSearch.test.ts

@@ -0,0 +1,122 @@
+import { describe, expect, test } from "bun:test"
+import type { DiscordThreadId } from "@chat-adapter/discord"
+import type { AdapterPostableMessage, FetchResult, RawMessage } from "chat"
+import { Effect } from "effect"
+import type { DiscordScope } from "../Schema.ts"
+import { makeChatSdkDiscord } from "./ChatSdkDiscord.ts"
+import { parseDiscordSearchQuery } from "./SearchQuery.ts"
+
+const scope: DiscordScope = { guildId: "g1", channelId: "c1", threadId: "t1" }
+
+class FakeDiscordAdapter {
+  encodeThreadId(input: DiscordThreadId): string {
+    return input.threadId === undefined
+      ? `discord:${input.guildId}:${input.channelId}`
+      : `discord:${input.guildId}:${input.channelId}:${input.threadId}`
+  }
+
+  postMessage(threadId: string, _message: AdapterPostableMessage): Promise<RawMessage<unknown>> {
+    return Promise.resolve({ id: "posted-1", threadId, raw: {} })
+  }
+
+  editMessage(threadId: string, messageId: string, _message: AdapterPostableMessage): Promise<RawMessage<unknown>> {
+    return Promise.resolve({ id: messageId, threadId, raw: {} })
+  }
+
+  deleteMessage(): Promise<void> {
+    return Promise.resolve()
+  }
+
+  startTyping(): Promise<void> {
+    return Promise.resolve()
+  }
+
+  addReaction(): Promise<void> {
+    return Promise.resolve()
+  }
+
+  fetchMessages(): Promise<FetchResult<unknown>> {
+    return Promise.resolve({ messages: [] })
+  }
+}
+
+describe("makeChatSdkDiscord search", () => {
+  test("searches guild messages through Discord REST search", async () => {
+    const requests: Array<string> = []
+    const originalFetch = globalThis.fetch
+    const fakeFetch: typeof fetch = Object.assign(
+      (input: URL | RequestInfo) => {
+        const url = String(input)
+        requests.push(url)
+        return Promise.resolve(url.includes("/messages/search") ? searchResponse() : memberResponse())
+      },
+      { preconnect: originalFetch.preconnect }
+    )
+    globalThis.fetch = fakeFetch
+
+    try {
+      const parsed = parseDiscordSearchQuery("hello from:<@123> in:<#789> has:link before:2026-06-06")
+      if (!parsed.ok) throw new Error(parsed.error)
+      const discord = makeChatSdkDiscord(new FakeDiscordAdapter(), { botToken: "token", apiUrl: "https://discord.test/api" })
+      const result = await Effect.runPromise(discord.searchMessages(scope, parsed.query, { limit: 25, offset: 0 }))
+
+      expect(result.totalResults).toBe(3)
+      expect(result.hasMore).toBe(true)
+      expect(result.messages).toEqual([
+        {
+          id: "m-search",
+          guildId: "g1",
+          channelId: "c1",
+          threadId: "789",
+          author: { id: "123", displayName: "Alice", nickname: "Ali the Great", isBot: false },
+          content: "hello link https://example.test",
+          timestamp: "2026-06-05T14:03:00.000Z",
+          mentions: ["456"],
+          roleMentions: ["111"],
+          everyoneMention: false,
+          hereMention: false,
+          attachments: [{ id: "a1", filename: "notes.txt", contentType: "text/plain", size: 42, url: "https://example.test/notes.txt" }],
+          reactions: [],
+          channelType: "guild"
+        }
+      ])
+    } finally {
+      globalThis.fetch = originalFetch
+    }
+
+    expect(requests[0]).toContain("/guilds/g1/messages/search?")
+    expect(requests[0]).toContain("content=hello")
+    expect(requests[0]).toContain("author_id=123")
+    expect(requests[0]).toContain("channel_id=789")
+    expect(requests[0]).toContain("has=link")
+    expect(requests[1]).toBe("https://discord.test/api/guilds/g1/members/123")
+  })
+})
+
+const memberResponse = (): Response =>
+  new Response(JSON.stringify({ nick: "Ali the Great" }), { status: 200, headers: { "content-type": "application/json" } })
+
+const searchResponse = (): Response =>
+  new Response(
+    JSON.stringify({
+      total_results: 3,
+      messages: [
+        [
+          {
+            id: "m-search",
+            channel_id: "789",
+            author: { id: "123", username: "alice", global_name: "Alice", bot: false },
+            content: "hello link https://example.test",
+            timestamp: "2026-06-05T14:03:00.000Z",
+            mentions: [{ id: "456" }],
+            mention_roles: ["111"],
+            mention_everyone: false,
+            attachments: [{ id: "a1", filename: "notes.txt", content_type: "text/plain", size: 42, url: "https://example.test/notes.txt" }],
+            type: 0
+          }
+        ]
+      ],
+      threads: [{ id: "789", parent_id: "c1" }]
+    }),
+    { status: 200, headers: { "content-type": "application/json" } }
+  )

package/src/Discord/DiscordJsDiscord.test.ts

@@ -112,7 +112,6 @@ describe("makeDiscordJsDiscord", () => {
       const file = join(directory, "upload.txt")
       await writeFile(file, "upload")
       const context = await Effect.runPromise(discord.fetchContext(scope, 1))
-      const history = await Effect.runPromise(discord.fetchHistory(scope, 1))
       await Effect.runPromise(discord.sendTyping(scope))
       const posted = await Effect.runPromise(discord.postMessage(scope, "hello"))
       await Effect.runPromise(discord.editMessage(scope, "m1", "edited"))
@@ -122,7 +121,6 @@ describe("makeDiscordJsDiscord", () => {
       expect(await Effect.runPromise(discord.createThread(scope, "work"))).toEqual({ id: "thread-1" })
 
       expect(context).toHaveLength(1)
-      expect(history).toHaveLength(1)
       expect(posted).toEqual({ id: "posted-1" })
       expect(attached).toEqual({ path: "posted-1" })
       expect(calls.map((call) => call[0])).toContain("delete")

package/src/Discord/DiscordJsDiscord.ts

@@ -194,7 +194,7 @@ export const makeDiscordJsDiscord = (client: DiscordJsClientLike): DiscordServic
         return mapped === undefined ? [] : [mapped]
       })
     }),
-  fetchHistory: (scope, limit) => makeDiscordJsDiscord(client).fetchContext(scope, limit),
+  searchMessages: () => Effect.fail(new DiscordError({ message: "Discord search is only available through the live REST adapter" })),
   sendTyping: (scope) =>
     Effect.gen(function* () {
       const channel = yield* fetchTextChannel(client, scope)

package/src/Discord/DiscordPort.ts

@@ -1,5 +1,5 @@
 import { Context, Data, type Duration, type Effect } from "effect"
-import type { DiscordMessage, DiscordScope } from "../Schema.ts"
+import type { DiscordMessage, DiscordScope, DiscordSearchQuery, DiscordSearchResult } from "../Schema.ts"
 
 export class DiscordError extends Data.TaggedError("DiscordError")<{
   readonly message: string
@@ -17,7 +17,11 @@ export type DiscordService = {
   readonly postMessage: (scope: DiscordScope, content: string) => Effect.Effect<{ readonly id: string }, DiscordError>
   readonly editMessage: (scope: DiscordScope, messageId: string, content: string) => Effect.Effect<void, DiscordError>
   readonly addReaction: (scope: DiscordScope, messageId: string, emoji: string) => Effect.Effect<void, DiscordError>
-  readonly fetchHistory: (scope: DiscordScope, limit: number) => Effect.Effect<ReadonlyArray<DiscordMessage>, DiscordError>
+  readonly searchMessages: (
+    scope: DiscordScope,
+    query: DiscordSearchQuery,
+    paging: { readonly limit: number; readonly offset: number }
+  ) => Effect.Effect<DiscordSearchResult, DiscordError>
   readonly attachFile: (scope: DiscordScope, path: string) => Effect.Effect<{ readonly path: string }, DiscordError>
   readonly createThread: (scope: DiscordScope, name: string) => Effect.Effect<{ readonly id: string }, DiscordError>
   readonly deleteMessage: (scope: DiscordScope, messageId: string) => Effect.Effect<void, DiscordError>