opencode-discord-bot 0.0.5 → 0.0.7

package/package.json

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

package/src/Bridge/LoopbackServer.test.ts

@@ -23,17 +23,18 @@ describe("startLoopbackServer", () => {
               method: "POST",
               headers: { "content-type": "application/json" },
               body: JSON.stringify({
-                action: "followUpMessage",
-                target: { guildId: "g1", channelId: "c1" },
-                args: { content: "from http" }
+                action: "addReaction",
+                target: { guildId: "g1", channelId: "c1", messageId: "m1" },
+                args: { emoji: "rocket" }
               })
             })
           )
           const body = yield* Effect.tryPromise(() => response.json())
 
           expect(server.url.startsWith("http://127.0.0.1:")).toBe(true)
-          expect(body).toEqual({ ok: true, result: { id: "posted-1" } })
-          expect(discord.messages).toEqual([{ scope: { guildId: "g1", channelId: "c1" }, content: "from http" }])
+          expect(body).toEqual({ ok: true, result: { reacted: true } })
+          expect(discord.reactions).toEqual([{ scope: { guildId: "g1", channelId: "c1" }, messageId: "m1", emoji: "rocket", op: "add" }])
+          expect(discord.messages).toEqual([])
         })
       )
     )
@@ -78,9 +79,9 @@ describe("startLoopbackServer", () => {
               method: "POST",
               headers: { "content-type": "application/json" },
               body: JSON.stringify({
-                action: "followUpMessage",
-                target: { guildId: "g1", channelId: "c2" },
-                args: { content: "outside" }
+                action: "addReaction",
+                target: { guildId: "g1", channelId: "c2", messageId: "m1" },
+                args: { emoji: "rocket" }
               })
             })
           )

package/src/Bridge/ToolControl.test.ts

@@ -14,14 +14,14 @@ const withTools = (tools: Partial<ToolConfig>): RuntimeConfig => ({
 })
 
 describe("handleToolRequest", () => {
-  test("allows safe default actions through the Discord port", async () => {
+  test("allows safe default non-message actions through the Discord port", async () => {
     const discord = makeMemoryDiscord()
     const response = await Effect.runPromise(
       handleToolRequest(
         {
-          action: "followUpMessage",
-          target: { guildId: "g1", channelId: "c1" },
-          args: { content: "done" }
+          action: "addReaction",
+          target: { guildId: "g1", channelId: "c1", messageId: "m1" },
+          args: { emoji: "rocket" }
         },
         defaultConfig,
         "/repo",
@@ -29,14 +29,15 @@ describe("handleToolRequest", () => {
       )
     )
 
-    expect(response.ok).toBe(true)
-    expect(discord.messages).toEqual([{ scope: { guildId: "g1", channelId: "c1" }, content: "done" }])
+    expect(response).toEqual({ ok: true, result: { reacted: true } })
+    expect(discord.reactions).toEqual([{ scope: { guildId: "g1", channelId: "c1" }, messageId: "m1", emoji: "rocket", op: "add" }])
+    expect(discord.messages).toEqual([])
   })
 
-  test("neutralizes mass mentions in follow-up tool content", async () => {
+  test("rejects stale message-sending bridge actions", async () => {
     const discord = makeMemoryDiscord()
 
-    const response = await Effect.runPromise(
+    const followUp = await Effect.runPromise(
       handleToolRequest(
         {
           action: "followUpMessage",
@@ -48,9 +49,22 @@ describe("handleToolRequest", () => {
         discord
       )
     )
+    const otherChannel = await Effect.runPromise(
+      handleToolRequest(
+        {
+          action: "postOtherChannel",
+          target: { guildId: "g1", channelId: "c2" },
+          args: { content: "elsewhere" }
+        },
+        defaultConfig,
+        "/repo",
+        discord
+      )
+    )
 
-    expect(response.ok).toBe(true)
-    expect(discord.messages).toEqual([{ scope: { guildId: "g1", channelId: "c1" }, content: "@ everyone @ here <@& 123>" }])
+    expect(followUp).toEqual({ ok: false, error: "Unknown action followUpMessage" })
+    expect(otherChannel).toEqual({ ok: false, error: "Unknown action postOtherChannel" })
+    expect(discord.messages).toEqual([])
   })
 
   test("blocks higher-risk actions unless explicitly enabled", async () => {
@@ -69,7 +83,7 @@ describe("handleToolRequest", () => {
   test("rejects DMs and unsafe attachment paths", async () => {
     const dm = await Effect.runPromise(
       handleToolRequest(
-        { action: "followUpMessage", target: { channelId: "dm1" }, args: { content: "nope" } },
+        { action: "addReaction", target: { guildId: "@me", channelId: "dm1", messageId: "m1" }, args: { emoji: "rocket" } },
         defaultConfig,
         "/repo",
         makeMemoryDiscord()
@@ -183,7 +197,7 @@ describe("handleToolRequest action dispatch", () => {
   test("rejects default tool targets outside the active turn scope", async () => {
     const response = await Effect.runPromise(
       handleToolRequest(
-        { action: "followUpMessage", target: { guildId: "g1", channelId: "other" }, args: { content: "nope" } },
+        { action: "addReaction", target: { guildId: "g1", channelId: "other", messageId: "m1" }, args: { emoji: "rocket" } },
         defaultConfig,
         "/repo",
         makeMemoryDiscord(),
@@ -197,7 +211,7 @@ describe("handleToolRequest action dispatch", () => {
   test("returns validation errors for malformed or unsupported requests", async () => {
     const disabled = await Effect.runPromise(
       handleToolRequest(
-        { action: "followUpMessage", target: { guildId: "g1", channelId: "c1" }, args: { content: "x" } },
+        { action: "addReaction", target: { guildId: "g1", channelId: "c1", messageId: "m1" }, args: { emoji: "rocket" } },
         withTools({ enabled: false }),
         "/repo",
         makeMemoryDiscord()
@@ -211,14 +225,6 @@ describe("handleToolRequest action dispatch", () => {
         makeMemoryDiscord()
       )
     )
-    const missingContent = await Effect.runPromise(
-      handleToolRequest(
-        { action: "followUpMessage", target: { guildId: "g1", channelId: "c1" }, args: {} },
-        defaultConfig,
-        "/repo",
-        makeMemoryDiscord()
-      )
-    )
     const missingReactionFields = await Effect.runPromise(
       handleToolRequest(
         { action: "addReaction", target: { guildId: "g1", channelId: "c1" }, args: {} },
@@ -238,7 +244,6 @@ describe("handleToolRequest action dispatch", () => {
 
     expect(disabled).toEqual({ ok: false, error: "Discord bridge tools are disabled" })
     expect(unknown).toEqual({ ok: false, error: "Unknown action unknown" })
-    expect(missingContent).toEqual({ ok: false, error: "content is required" })
     expect(missingReactionFields).toEqual({ ok: false, error: "messageId and emoji are required" })
     expect(missingPath).toEqual({ ok: false, error: "path is required" })
   })

package/src/Bridge/ToolControl.ts

@@ -20,15 +20,11 @@ const actionFlag = (action: string): keyof ToolConfig | undefined => {
       return "attachFiles"
     case "fetchHistory":
       return "fetchHistory"
-    case "followUpMessage":
-      return "followUpMessages"
     case "createThread":
       return "createThread"
     case "editOwnMessage":
     case "deleteOwnMessage":
       return "editDeleteOwn"
-    case "postOtherChannel":
-      return "postOtherChannels"
     case "pin":
     case "unpin":
       return "pin"
@@ -74,18 +70,6 @@ const attachmentPath = Effect.fn("attachmentPath")(function* (projectDir: string
 
 const disabled = (action: string): ToolResponse => ({ ok: false, error: `Action ${action} is disabled` })
 
-const followUp = Effect.fn("toolFollowUp")(function* (
-  request: ToolRequest,
-  scope: DiscordScope,
-  config: RuntimeConfig,
-  discord: DiscordService
-) {
-  const content = stringArg(request, "content")
-  if (content === undefined || content.trim() === "") return { ok: false, error: "content is required" } satisfies ToolResponse
-  const result = yield* discord.postMessage(scope, sanitizeDiscordContent(content, config.guards))
-  return { ok: true, result } satisfies ToolResponse
-})
-
 const reaction = Effect.fn("toolReaction")(function* (
   request: ToolRequest,
   scope: DiscordScope,
@@ -183,21 +167,6 @@ const deleteOwnMessage = Effect.fn("toolDeleteOwnMessage")(function* (
   return { ok: true, result: { deleted: true } } satisfies ToolResponse
 })
 
-const postOtherChannel = Effect.fn("toolPostOtherChannel")(function* (
-  request: ToolRequest,
-  config: RuntimeConfig,
-  discord: DiscordService
-) {
-  const guildId = request.target.guildId
-  const channelId = request.target.channelId
-  const content = stringArg(request, "content")
-  if (guildId === undefined || channelId === undefined || content === undefined || content.trim() === "") {
-    return { ok: false, error: "guildId, channelId, and content are required" } satisfies ToolResponse
-  }
-  const result = yield* discord.postChannelMessage(guildId, channelId, sanitizeDiscordContent(content, config.guards))
-  return { ok: true, result } satisfies ToolResponse
-})
-
 const pin = Effect.fn("toolPin")(function* (
   request: ToolRequest,
   scope: DiscordScope,
@@ -228,13 +197,11 @@ export const handleToolRequest = Effect.fn("handleToolRequest")(function* (
 
   const scope = scopeFromRequest(request)
   if (typeof scope === "string") return { ok: false, error: scope } satisfies ToolResponse
-  if (request.action !== "postOtherChannel" && !isAllowedScope(scope, options.allowedScopes)) {
+  if (!isAllowedScope(scope, options.allowedScopes)) {
     return { ok: false, error: "Discord target is outside the active turn scope" } satisfies ToolResponse
   }
 
   switch (request.action) {
-    case "followUpMessage":
-      return yield* followUp(request, scope, config, discord)
     case "addReaction":
       return yield* reaction(request, scope, discord, "add")
     case "removeReaction":
@@ -249,8 +216,6 @@ export const handleToolRequest = Effect.fn("handleToolRequest")(function* (
       return yield* editOwnMessage(request, scope, config, discord, options)
     case "deleteOwnMessage":
       return yield* deleteOwnMessage(request, scope, config, discord, options)
-    case "postOtherChannel":
-      return yield* postOtherChannel(request, config, discord)
     case "pin":
       return yield* pin(request, scope, discord, "pin")
     case "unpin":

package/src/Bridge/ToolControlEdges.test.ts

@@ -28,7 +28,7 @@ test("rejects missing attachment files inside the project", async () => {
 test("rejects incomplete high-risk tool payloads before dispatch", async () => {
   const config = {
     ...defaultConfig,
-    tools: { ...defaultConfig.tools, editDeleteOwn: true, postOtherChannels: true }
+    tools: { ...defaultConfig.tools, editDeleteOwn: true }
   }
   const discord = makeMemoryDiscord()
 
@@ -40,10 +40,6 @@ test("rejects incomplete high-risk tool payloads before dispatch", async () => {
       discord
     )
   )
-  const post = await Effect.runPromise(
-    handleToolRequest({ action: "postOtherChannel", target: { guildId: "g1", channelId: "c2" }, args: {} }, config, "/repo", discord)
-  )
 
   expect(edit).toEqual({ ok: false, error: "messageId and content are required" })
-  expect(post).toEqual({ ok: false, error: "guildId, channelId, and content are required" })
 })

package/src/Bridge/ToolControlHighRisk.test.ts

@@ -31,7 +31,7 @@ describe("handleToolRequest high-risk actions", () => {
         }
       ]
     })
-    const config = withTools({ createThread: true, editDeleteOwn: true, postOtherChannels: true, pin: true })
+    const config = withTools({ createThread: true, editDeleteOwn: true, pin: true })
 
     const created = await Effect.runPromise(
       handleToolRequest(
@@ -60,14 +60,6 @@ describe("handleToolRequest high-risk actions", () => {
         { botId: "bot-1" }
       )
     )
-    const posted = await Effect.runPromise(
-      handleToolRequest(
-        { action: "postOtherChannel", target: { guildId: "g1", channelId: "c2" }, args: { content: "elsewhere" } },
-        config,
-        "/repo",
-        discord
-      )
-    )
     const pinned = await Effect.runPromise(
       handleToolRequest({ action: "pin", target: { guildId: "g1", channelId: "c1", messageId: "m1" }, args: {} }, config, "/repo", discord)
     )
@@ -83,11 +75,9 @@ describe("handleToolRequest high-risk actions", () => {
     expect(created).toEqual({ ok: true, result: { id: "thread-1" } })
     expect(edited).toEqual({ ok: true, result: { edited: true } })
     expect(deleted).toEqual({ ok: true, result: { deleted: true } })
-    expect(posted).toEqual({ ok: true, result: { id: "posted-2" } })
     expect(pinned).toEqual({ ok: true, result: { pinned: true } })
     expect(unpinned).toEqual({ ok: true, result: { pinned: false } })
     expect(discord.threads).toEqual([{ scope: { guildId: "g1", channelId: "c1" }, name: "work" }])
-    expect(discord.channelMessages).toEqual([{ guildId: "g1", channelId: "c2", content: "elsewhere" }])
     expect(discord.pins.map((item) => item.op)).toEqual(["pin", "unpin"])
   })
 
@@ -137,17 +127,4 @@ describe("handleToolRequest high-risk actions", () => {
     expect(discord.edits).toEqual([])
     expect(discord.deletes).toEqual([])
   })
-
-  test("rejects DM-like targets even when cross-channel posting is enabled", async () => {
-    const response = await Effect.runPromise(
-      handleToolRequest(
-        { action: "postOtherChannel", target: { guildId: "@me", channelId: "dm" }, args: { content: "nope" } },
-        withTools({ postOtherChannels: true }),
-        "/repo",
-        makeMemoryDiscord()
-      )
-    )
-
-    expect(response).toEqual({ ok: false, error: "Discord DMs are not supported" })
-  })
 })

package/src/Config.test.ts

@@ -24,7 +24,7 @@ describe("loadConfigFromSources", () => {
           "threads": { "activeByRecentBotParticipation": false },
           "concurrency": { "strategy": "burst", "globalMaxActiveTurns": 4 },
           "guards": { "ignoreBots": false, "stripMassMentions": false, "redactSecretsInErrors": false, "maxTurnMs": 1000 },
-          "tools": { "createThread": true, "pin": true }
+          "tools": { "createThread": true, "pin": true, "followUpMessages": true, "postOtherChannels": true }
         }`
       })
     )
@@ -48,6 +48,8 @@ describe("loadConfigFromSources", () => {
     expect(config.tools.reactions).toBe(true)
     expect(config.tools.createThread).toBe(true)
     expect(config.tools.pin).toBe(true)
+    expect("followUpMessages" in config.tools).toBe(false)
+    expect("postOtherChannels" in config.tools).toBe(false)
   })
 
   test("uses the normative localhost defaults", async () => {
@@ -59,8 +61,8 @@ describe("loadConfigFromSources", () => {
     expect(config.bridge.port).toBe(8787)
     expect(config.context.messages).toBe(30)
     expect(config.tools.autoInstall).toBe(true)
-    expect(config.tools.followUpMessages).toBe(true)
-    expect(config.tools.postOtherChannels).toBe(false)
+    expect("followUpMessages" in config.tools).toBe(false)
+    expect("postOtherChannels" in config.tools).toBe(false)
   })
 
   test("fails fast when DISCORD_TOKEN is missing", async () => {

package/src/Config.ts

@@ -17,10 +17,8 @@ export type ToolConfig = {
   readonly reactions: boolean
   readonly attachFiles: boolean
   readonly fetchHistory: boolean
-  readonly followUpMessages: boolean
   readonly createThread: boolean
   readonly editDeleteOwn: boolean
-  readonly postOtherChannels: boolean
   readonly pin: boolean
 }
 
@@ -96,10 +94,8 @@ export const defaultConfig: RuntimeConfig = {
     reactions: true,
     attachFiles: true,
     fetchHistory: true,
-    followUpMessages: true,
     createThread: false,
     editDeleteOwn: false,
-    postOtherChannels: false,
     pin: false
   },
   streaming: {
@@ -263,10 +259,8 @@ export const loadConfigFromSources = Effect.fn("loadConfigFromSources")(function
       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: {

package/src/ConfigSchema.ts

@@ -8,10 +8,8 @@ const RawToolsSchema = Schema.Struct({
   reactions: OptionalBoolean,
   attachFiles: OptionalBoolean,
   fetchHistory: OptionalBoolean,
-  followUpMessages: OptionalBoolean,
   createThread: OptionalBoolean,
   editDeleteOwn: OptionalBoolean,
-  postOtherChannels: OptionalBoolean,
   pin: OptionalBoolean
 })
 

package/src/Discord/ChatSdkDiscord.test.ts

@@ -3,7 +3,7 @@ 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 type { AdapterPostableMessage, FetchResult, RawMessage } from "chat"
 import { Message, parseMarkdown } from "chat"
 import { Duration, Effect } from "effect"
 import type { DiscordScope } from "../Schema.ts"
@@ -37,16 +37,6 @@ class FakeDiscordAdapter {
     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()
@@ -142,7 +132,24 @@ describe("makeChatSdkDiscord", () => {
     ])
   })
 
-  test("routes channel posts, deletes, and raw REST adapter gaps", async () => {
+  test("normalizes Discord user mention wrappers before chat-sdk output conversion", async () => {
+    const adapter = new FakeDiscordAdapter()
+    const discord = makeChatSdkDiscord(adapter)
+
+    const posted = await Effect.runPromise(discord.postMessage(scope, "hello <@999> and <@!888>"))
+    await Effect.runPromise(discord.editMessage(scope, posted.id, "edited <@777>"))
+
+    expect(adapter.calls).toEqual([
+      ["encodeThreadId", { guildId: "g1", channelId: "c1", threadId: "t1" }],
+      ["postMessage", { threadId: "discord:g1:c1:t1", message: "hello @999 and @888" }],
+      ["encodeThreadId", { guildId: "g1", channelId: "c1", threadId: "t1" }],
+      ["editMessage", { threadId: "discord:g1:c1:t1", messageId: "posted-1", message: "edited @777" }]
+    ])
+  })
+})
+
+describe("makeChatSdkDiscord REST operations", () => {
+  test("routes deletes and raw REST adapter gaps", async () => {
     const adapter = new FakeDiscordAdapter()
     const requests: Array<readonly [string, RequestInit]> = []
     const originalFetch = globalThis.fetch
@@ -164,7 +171,6 @@ describe("makeChatSdkDiscord", () => {
       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"))
@@ -172,13 +178,7 @@ describe("makeChatSdkDiscord", () => {
       globalThis.fetch = originalFetch
     }
 
-    expect(adapter.calls.map((item) => item[0])).toEqual([
-      "encodeThreadId",
-      "deleteMessage",
-      "encodeThreadId",
-      "fetchChannelInfo",
-      "postChannelMessage"
-    ])
+    expect(adapter.calls.map((item) => item[0])).toEqual(["encodeThreadId", "deleteMessage"])
     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"],
@@ -213,21 +213,6 @@ describe("makeChatSdkDiscord", () => {
     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(

package/src/Discord/ChatSdkDiscord.ts

@@ -1,7 +1,7 @@
 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 type { AdapterPostableMessage, 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"
@@ -9,14 +9,12 @@ 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 = {
@@ -37,11 +35,6 @@ const mentions = (content: string): ReadonlyArray<string> => [...content.matchAl
 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}`,
@@ -87,17 +80,6 @@ const retryAfterFromCause = (cause: unknown) => {
   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,
@@ -142,6 +124,8 @@ const rawDiscord = (options: RawDiscordOptions | undefined, path: string, init:
     return await response.json()
   })
 
+const normalizeMentionsForChatAdapter = (content: string): string => content.replace(/<@!?(\w+)>/g, "@$1")
+
 export const makeChatSdkDiscord = (adapter: ChatDiscordAdapter, raw: RawDiscordOptions | undefined = undefined): DiscordService => ({
   fetchContext: (scope, limit) =>
     tryAdapter(async () => {
@@ -158,11 +142,13 @@ export const makeChatSdkDiscord = (adapter: ChatDiscordAdapter, raw: RawDiscordO
   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)
+      const result = await adapter.postMessage(threadIdFromScope(adapter, scope), normalizeMentionsForChatAdapter(content))
       return { id: result.id }
     }),
   editMessage: (scope, messageId, content) =>
-    tryAdapter(() => adapter.editMessage(threadIdFromScope(adapter, scope), messageId, content)).pipe(Effect.asVoid),
+    tryAdapter(() => adapter.editMessage(threadIdFromScope(adapter, scope), messageId, normalizeMentionsForChatAdapter(content))).pipe(
+      Effect.asVoid
+    ),
   deleteMessage: (scope, messageId) =>
     tryAdapter(() => adapter.deleteMessage(threadIdFromScope(adapter, scope), messageId)).pipe(Effect.asVoid),
   addReaction: (scope, messageId, emoji) =>
@@ -180,21 +166,12 @@ export const makeChatSdkDiscord = (adapter: ChatDiscordAdapter, raw: RawDiscordO
       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({

package/src/Discord/ChatSdkGatewayIntake.test.ts

@@ -42,6 +42,7 @@ test("maps Discord messages through the chat-sdk adapter facade", async () => {
   const parsed = adapter.parseMessage(withAttachment)
 
   expect(adapter.encodeThreadId({ guildId: "g1", channelId: "c1", threadId: "t1" })).toBe("discord:g1:c1:t1")
+  expect(adapter.userName).toBe("self")
   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")

package/src/Discord/ChatSdkGatewayIntake.ts

@@ -175,7 +175,7 @@ const unsupported = (operation: string): Promise<never> => Promise.reject(new Er
 
 export const makeGatewayAdapter = (bot: BotIdentity): Adapter<DiscordScope, DiscordMessage> => ({
   name: "discord",
-  userName: `<@${bot.userId}>`,
+  userName: bot.userId,
   botUserId: bot.userId,
   lockScope: "thread",
   initialize: () => Promise.resolve(),
@@ -208,7 +208,7 @@ export const makeChatGatewayIntake = (options: ChatGatewayIntakeOptions): ChatGa
   const chat = new Chat({
     adapters: { discord: adapter },
     state: makeTransientChatState(),
-    userName: `<@${options.bot.userId}>`,
+    userName: options.bot.userId,
     concurrency: "concurrent",
     dedupeTtlMs: 5 * 60 * 1000
   })

package/src/Discord/DiscordJsDiscord.test.ts

@@ -134,7 +134,6 @@ describe("makeDiscordJsDiscord", () => {
       await Effect.runPromise(discord.removeReaction(scope, "m1", "rocket"))
       const attached = await Effect.runPromise(discord.attachFile(scope, file))
       expect(await Effect.runPromise(discord.createThread(scope, "work"))).toEqual({ id: "thread-1" })
-      expect(await Effect.runPromise(discord.postChannelMessage("g1", "c2", "hello"))).toEqual({ id: "posted-1" })
       await Effect.runPromise(discord.pinMessage(scope, "m1"))
       await Effect.runPromise(discord.unpinMessage(scope, "m1"))
 

package/src/Discord/DiscordJsDiscord.ts

@@ -246,12 +246,6 @@ export const makeDiscordJsDiscord = (client: DiscordJsClientLike): DiscordServic
       if (channel.threads === undefined) return yield* Effect.fail(new DiscordError({ message: "Discord channel cannot create threads" }))
       return yield* tryDiscord(() => channel.threads?.create({ name }) ?? Promise.resolve({ id: "" }))
     }),
-  postChannelMessage: (_guildId, channelId, content) =>
-    Effect.gen(function* () {
-      const channel = yield* fetchTextChannel(client, { guildId: _guildId, channelId })
-      const result = yield* tryDiscord(() => channel.send(content))
-      return { id: result.id }
-    }),
   pinMessage: (scope, messageId) =>
     Effect.gen(function* () {
       const message = yield* fetchMessage(client, scope, messageId)

package/src/Discord/DiscordPort.ts

@@ -22,7 +22,6 @@ export type DiscordService = {
   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>
-  readonly postChannelMessage: (guildId: string, channelId: string, content: string) => Effect.Effect<{ readonly id: string }, DiscordError>
   readonly pinMessage: (scope: DiscordScope, messageId: string) => Effect.Effect<void, DiscordError>
   readonly unpinMessage: (scope: DiscordScope, messageId: string) => Effect.Effect<void, DiscordError>
 }

package/src/Discord/MemoryDiscord.ts

@@ -20,7 +20,6 @@ export type MemoryDiscord = DiscordService & {
   readonly attachments: Array<{ readonly scope: DiscordScope; readonly path: string }>
   readonly threads: Array<{ readonly scope: DiscordScope; readonly name: string }>
   readonly deletes: Array<{ readonly scope: DiscordScope; readonly messageId: string }>
-  readonly channelMessages: Array<{ readonly guildId: string; readonly channelId: string; readonly content: string }>
   readonly pins: Array<{ readonly scope: DiscordScope; readonly messageId: string; readonly op: "pin" | "unpin" }>
 }
 
@@ -34,7 +33,6 @@ export const makeMemoryDiscord = (options: MemoryOptions = {}): MemoryDiscord =>
   const attachments: MemoryDiscord["attachments"] = []
   const threads: MemoryDiscord["threads"] = []
   const deletes: MemoryDiscord["deletes"] = []
-  const channelMessages: MemoryDiscord["channelMessages"] = []
   const pins: MemoryDiscord["pins"] = []
 
   return {
@@ -46,7 +44,6 @@ export const makeMemoryDiscord = (options: MemoryOptions = {}): MemoryDiscord =>
     attachments,
     threads,
     deletes,
-    channelMessages,
     pins,
     fetchContext: (_scope, limit) => Effect.succeed(context.slice(Math.max(0, context.length - limit))),
     sendTyping: (scope) => Effect.sync(() => typingScopes.push(scope)).pipe(Effect.asVoid),
@@ -73,12 +70,6 @@ export const makeMemoryDiscord = (options: MemoryOptions = {}): MemoryDiscord =>
         return { id: `thread-${nextId}` }
       }),
     deleteMessage: (scope, messageId) => Effect.sync(() => deletes.push({ scope, messageId })).pipe(Effect.asVoid),
-    postChannelMessage: (guildId, channelId, content) =>
-      Effect.sync(() => {
-        nextId += 1
-        channelMessages.push({ guildId, channelId, content })
-        return { id: `posted-${nextId}` }
-      }),
     pinMessage: (scope, messageId) => Effect.sync(() => pins.push({ scope, messageId, op: "pin" })).pipe(Effect.asVoid),
     unpinMessage: (scope, messageId) => Effect.sync(() => pins.push({ scope, messageId, op: "unpin" })).pipe(Effect.asVoid)
   }

package/src/Main.test.ts

@@ -124,7 +124,6 @@ describe("makeApplication startup", () => {
       attachFile: () => Effect.succeed({ path: "out.txt" }),
       createThread: () => Effect.succeed({ id: "thread" }),
       deleteMessage: () => Effect.void,
-      postChannelMessage: () => Effect.succeed({ id: "posted" }),
       pinMessage: () => Effect.void,
       unpinMessage: () => Effect.void
     }
@@ -203,16 +202,17 @@ describe("makeApplication facade", () => {
     await new Promise((resolve) => setTimeout(resolve, 0))
     const response = await Effect.runPromise(
       app.handleTool({
-        action: "followUpMessage",
-        target: { guildId: "g1", channelId: "c1" },
-        args: { content: "hello @everyone <@&123>" }
+        action: "addReaction",
+        target: { guildId: "g1", channelId: "c1", messageId: "m1" },
+        args: { emoji: "rocket" }
       })
     )
     releaseTurn?.()
     await running
 
-    expect(response).toEqual({ ok: true, result: { id: "posted-1" } })
-    expect(discord.messages.map((item) => item.content)).toEqual(["hello @ everyone <@& 123>"])
+    expect(response).toEqual({ ok: true, result: { reacted: true } })
+    expect(discord.reactions).toEqual([{ scope: { guildId: "g1", channelId: "c1" }, messageId: "m1", emoji: "rocket", op: "add" }])
+    expect(discord.messages).toEqual([])
   })
 
   test("runs message turns and stop commands through the application facade", async () => {

package/src/Orchestrator/ContextAssembly.test.ts

@@ -51,8 +51,10 @@ describe("context assembly", () => {
 
     expect(prompt.messages.map((item) => item.id)).toEqual(["1", "2", "3"])
     expect(prompt.text.match(/latest <@999>/g)).toHaveLength(1)
+    expect(prompt.text).toContain("Plain assistant text is streamed to Discord automatically")
+    expect(prompt.text).toContain("do not use bridge tools to send messages")
     expect(prompt.text).toContain("<@id> pings that user in Discord")
-    expect(prompt.text).toContain("Use discord target metadata when calling bridge tools")
+    expect(prompt.text).toContain("Use discord target metadata when calling non-message bridge tools")
     expect(prompt.text).toContain("Do not emit @everyone, @here, or role pings")
   })
 

package/src/Orchestrator/ContextAssembly.ts

@@ -18,7 +18,7 @@ type ContextInput = {
 }
 
 const preamble = (botUserId: string) =>
-  `Discord bridge context for <@${botUserId}>. <@id> pings that user in Discord. Use discord target metadata when calling bridge tools. Do not emit @everyone, @here, or role pings unless explicitly allowed.`
+  `Discord bridge context for <@${botUserId}>. Plain assistant text is streamed to Discord automatically; do not use bridge tools to send messages. <@id> pings that user in Discord. Use discord target metadata when calling non-message bridge tools. Do not emit @everyone, @here, or role pings unless explicitly allowed.`
 
 const timestamp = (value: string): string => {
   const date = new Date(value)

package/src/Tools/DiscordBridgeTool.ts

@@ -3,11 +3,10 @@ import { tool } from "@opencode-ai/plugin"
 const loopbackToolUrl = "__OPENCODE_DISCORD_BOT_LOOPBACK_URL__/tool"
 
 export default tool({
-  description: "Perform safe Discord bridge actions through the local opencode-discord-bot process.",
+  description: "Perform non-message Discord bridge actions through the local opencode-discord-bot process.",
   args: {
     action: tool.schema
       .enum([
-        "followUpMessage",
         "addReaction",
         "removeReaction",
         "fetchHistory",
@@ -15,7 +14,6 @@ export default tool({
         "createThread",
         "editOwnMessage",
         "deleteOwnMessage",
-        "postOtherChannel",
         "pin",
         "unpin"
       ])
@@ -30,7 +28,7 @@ export default tool({
       .describe("Discord target for the action."),
     args: tool.schema
       .record(tool.schema.string(), tool.schema.unknown())
-      .describe("Action-specific arguments, such as content, emoji, limit, path, or name.")
+      .describe("Action-specific arguments, such as emoji, limit, path, name, or replacement content for editOwnMessage.")
   },
   async execute(request) {
     const response = await fetch(loopbackToolUrl, {

package/src/Tools/Scaffolding.test.ts

@@ -16,6 +16,8 @@ describe("Discord tool scaffolding", () => {
     expect(source).toContain(".enum([")
     expect(source).toContain('"fetchHistory"')
     expect(source).toContain('"addReaction"')
+    expect(source).not.toContain('"followUpMessage"')
+    expect(source).not.toContain('"postOtherChannel"')
     expect(source).toContain(".record(tool.schema.string(), tool.schema.unknown())")
     expect(source).toContain("fetch")
     expect(source).not.toContain("export const parameters")