opencode-discord-bot 0.0.2 → 0.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-discord-bot",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "description": "Discord bot bridge for a self-hosted opencode instance",
   "type": "module",
   "main": "src/Main.ts",
@@ -68,6 +68,7 @@
     "@commitlint/cli": "^21.0.2",
     "@commitlint/config-conventional": "^21.0.2",
     "@effect/vitest": "4.0.0-beta.74",
+    "@opencode-ai/plugin": "1.16.2",
     "@types/bun": "1.3.13",
     "@typescript/native-preview": "^7.0.0-dev.20260606.1",
     "@vitest/coverage-v8": "^4.1.8",

package/src/Main.test.ts

@@ -41,6 +41,12 @@ const mentionMessage = {
   channelType: "guild"
 } satisfies DiscordMessage
 
+const makeTestEnv = (projectDir: string, bridgePort: number) => ({
+  DISCORD_TOKEN: "token",
+  OPENCODE_PROJECT_DIR: projectDir,
+  DISCORD_BRIDGE_PORT: bridgePort.toString()
+})
+
 describe("makeProgram", () => {
   test("runs Bun preflight, loads config, and scaffolds generated Discord tools", async () => {
     const projectDir = await mkdtemp(join(tmpdir(), "ocdb-program-"))
@@ -54,11 +60,11 @@ describe("makeProgram", () => {
     }
 
     try {
-      await Effect.runPromise(makeProgram(projectDir, { DISCORD_TOKEN: "token", OPENCODE_PROJECT_DIR: projectDir }, factories))
+      await Effect.runPromise(makeProgram(projectDir, makeTestEnv(projectDir, 18_787), factories))
       const tool = await readFile(join(projectDir, ".opencode", "tools", "discord-bridge.ts"), "utf8")
 
       expect(tool).toContain("Generated by opencode-discord-bot")
-      expect(tool).toContain("http://127.0.0.1:8787/tool")
+      expect(tool).toContain("http://127.0.0.1:18787/tool")
     } finally {
       await rm(projectDir, { recursive: true, force: true })
     }
@@ -152,7 +158,7 @@ describe("makeProgram callbacks", () => {
     }
 
     try {
-      await Effect.runPromise(makeProgram(projectDir, { DISCORD_TOKEN: "token", OPENCODE_PROJECT_DIR: projectDir }, factories))
+      await Effect.runPromise(makeProgram(projectDir, makeTestEnv(projectDir, 18_788), factories))
       if (gatewayOptions === undefined) throw new Error("gateway options were not captured")
 
       await Effect.runPromise(gatewayOptions.onMessage(mentionMessage, { userId: "self" }))

package/src/Opencode/EventMapping.test.ts

@@ -59,6 +59,47 @@ describe("opencode event mapping", () => {
     expect(decodeOpencodeEvent({ type: "message.part.delta", part: { type: "reasoning" }, delta: "hidden" })).toBeUndefined()
   })
 
+  test("preserves text part ids and maps hidden reasoning to typing events", async () => {
+    const events = await Effect.runPromise(
+      opencodeEventStream(
+        Stream.fromIterable([
+          { type: "session.next.reasoning.started", properties: { sessionID: "s1", reasoningID: "r1" } },
+          { type: "session.next.text.delta", properties: { sessionID: "s1", textID: "text-1", delta: "hello" } },
+          { type: "session.next.text.ended", properties: { sessionID: "s1", textID: "text-1", text: "hello" } },
+          {
+            type: "message.updated",
+            properties: { sessionID: "s1", info: { id: "assistant-message", role: "assistant" } }
+          },
+          {
+            type: "message.part.delta",
+            properties: {
+              sessionID: "s1",
+              messageID: "assistant-message",
+              partID: "text-2",
+              part: { sessionID: "s1", messageID: "assistant-message", type: "text" },
+              delta: " second"
+            }
+          },
+          {
+            type: "message.part.updated",
+            properties: {
+              sessionID: "s1",
+              part: { id: "text-3", sessionID: "s1", messageID: "assistant-message", type: "text", text: "third" }
+            }
+          }
+        ])
+      ).pipe(Stream.runCollect)
+    )
+
+    expect(events).toEqual([
+      { type: "reasoning-start" },
+      { type: "text-delta", id: "text-1", text: "hello" },
+      { type: "text-snapshot", id: "text-1", text: "hello" },
+      { type: "text-delta", id: "text-2", text: " second" },
+      { type: "text-snapshot", id: "text-3", text: "third" }
+    ])
+  })
+
   test("maps wrapped SDK events and delta-bearing part updates", () => {
     expect(
       decodeOpencodeEvent({
@@ -183,6 +224,6 @@ describe("opencode event mapping", () => {
       ).pipe(Stream.runCollect)
     )
 
-    expect(events).toEqual([{ type: "text-snapshot", text: "Normal answer" }, { type: "idle" }])
+    expect(events).toEqual([{ type: "text-snapshot", id: "assistant-text", text: "Normal answer" }, { type: "idle" }])
   })
 })

package/src/Opencode/EventMapping.ts

@@ -38,6 +38,24 @@ const textPart = (value: unknown): Readonly<Record<string, unknown>> | undefined
   return stringField(value, "type") === "text" ? value : undefined
 }
 
+const textId = (record: Readonly<Record<string, unknown>>): string | undefined =>
+  stringField(record, "textID") ?? stringField(record, "textId")
+
+const partId = (record: Readonly<Record<string, unknown>>): string | undefined =>
+  stringField(record, "id") ?? stringField(record, "partID") ?? stringField(record, "partId")
+
+const messagePartId = (
+  payload: Readonly<Record<string, unknown>>,
+  properties: Readonly<Record<string, unknown>>,
+  part: Readonly<Record<string, unknown>> | undefined
+): string | undefined =>
+  (part === undefined ? undefined : partId(part)) ??
+  textId(properties) ??
+  stringField(properties, "partID") ??
+  stringField(properties, "partId") ??
+  stringField(payload, "partID") ??
+  stringField(payload, "partId")
+
 const errorMessage = (value: unknown): string => {
   if (!isRecord(value)) return "Unknown opencode error"
   const properties = payloadProperties(value)
@@ -107,11 +125,15 @@ const decodeText = (properties: Readonly<Record<string, unknown>>, type: string
   switch (type) {
     case "session.next.text.delta": {
       const delta = stringField(properties, "delta")
-      return delta === undefined ? undefined : { type: "text-delta", text: delta }
+      if (delta === undefined) return undefined
+      const id = textId(properties)
+      return id === undefined ? { type: "text-delta", text: delta } : { type: "text-delta", id, text: delta }
     }
     case "session.next.text.ended": {
       const text = stringField(properties, "text")
-      return text === undefined ? undefined : { type: "text-snapshot", text }
+      if (text === undefined) return undefined
+      const id = textId(properties)
+      return id === undefined ? { type: "text-snapshot", text } : { type: "text-snapshot", id, text }
     }
     default:
       return undefined
@@ -120,10 +142,12 @@ const decodeText = (properties: Readonly<Record<string, unknown>>, type: string
 
 const textDelta = (
   payload: Readonly<Record<string, unknown>>,
-  properties: Readonly<Record<string, unknown>>
+  properties: Readonly<Record<string, unknown>>,
+  id: string | undefined
 ): OpencodeEvent | undefined => {
   const delta = stringField(properties, "delta") ?? stringField(payload, "delta")
-  return delta === undefined ? undefined : { type: "text-delta", text: delta }
+  if (delta === undefined) return undefined
+  return id === undefined ? { type: "text-delta", text: delta } : { type: "text-delta", id, text: delta }
 }
 
 const decodePartDelta = (
@@ -132,9 +156,13 @@ const decodePartDelta = (
   options: DecodeOptions
 ): OpencodeEvent | undefined => {
   const part = properties.part ?? payload.part
-  if (part !== undefined) return textPart(part) === undefined ? undefined : textDelta(payload, properties)
+  if (part !== undefined) {
+    const text = textPart(part)
+    return text === undefined ? undefined : textDelta(payload, properties, messagePartId(payload, properties, text))
+  }
   if (options.includeGenericPartDeltas !== true) return undefined
-  return stringField(properties, "field") === "text" ? textDelta(payload, properties) : undefined
+  const id = messagePartId(payload, properties, undefined)
+  return stringField(properties, "field") === "text" ? textDelta(payload, properties, id) : undefined
 }
 
 const decodePartUpdated = (
@@ -143,12 +171,17 @@ const decodePartUpdated = (
 ): OpencodeEvent | undefined => {
   const part = textPart(properties.part ?? payload.part)
   if (part === undefined) return undefined
-  const delta = textDelta(payload, properties)
+  const id = messagePartId(payload, properties, part)
+  const delta = textDelta(payload, properties, id)
   if (delta !== undefined) return delta
   const text = stringField(part, "text")
-  return text === undefined ? undefined : { type: "text-snapshot", text }
+  if (text === undefined) return undefined
+  return id === undefined ? { type: "text-snapshot", text } : { type: "text-snapshot", id, text }
 }
 
+const decodeReasoning = (type: string | undefined): OpencodeEvent | undefined =>
+  type === "session.next.reasoning.started" ? { type: "reasoning-start" } : undefined
+
 const decodePart = (
   payload: Readonly<Record<string, unknown>>,
   properties: Readonly<Record<string, unknown>>,
@@ -213,6 +246,7 @@ export const decodeOpencodeEvent = (payload: unknown, options: DecodeOptions = {
   return (
     decodeLifecycle(event, type) ??
     decodeText(properties, type) ??
+    decodeReasoning(type) ??
     decodePart(event, properties, type, options) ??
     decodeTool(event, type) ??
     decodeStep(event, type)

package/src/Render/Renderer.ts

@@ -17,6 +17,12 @@ type PostedChunk = {
   content: string
 }
 
+type RenderSegment = {
+  readonly id: string | undefined
+  text: string
+  readonly posted: Array<PostedChunk>
+}
+
 const discordRetrySchedule = Schedule.fromStepWithMetadata(
   Effect.succeed((metadata: Schedule.InputMetadata<DiscordError>) => {
     if (metadata.attempt > 2) return Cause.done(metadata.attempt)
@@ -34,16 +40,31 @@ export const renderOpencodeEvents = Effect.fn("renderOpencodeEvents")(function*
   config: RuntimeConfig,
   discord: DiscordService
 ) {
-  let answer = ""
   let changed: string | undefined
-  const posted: Array<PostedChunk> = []
+  const segments: Array<RenderSegment> = []
+  const segmentsById = new Map<string, RenderSegment>()
   const updateIntervalMs = Math.max(0, Duration.toMillis(config.streaming.updateInterval))
   let lastFlushAt = Number.NEGATIVE_INFINITY
   let typingFiber: Fiber.Fiber<void, never> | undefined
   let status: PostedChunk | undefined
   let finished = false
 
-  const visibleContent = () => sanitizeDiscordContent(changed === undefined ? answer : `${answer}\n\n${changed}`.trim(), config.guards)
+  const lastSegment = (): RenderSegment | undefined => segments[segments.length - 1]
+  const createSegment = (id: string | undefined): RenderSegment => {
+    const segment: RenderSegment = { id, text: "", posted: [] }
+    segments.push(segment)
+    if (id !== undefined) segmentsById.set(id, segment)
+    return segment
+  }
+  const getSegment = (id: string | undefined): RenderSegment => {
+    if (id !== undefined) return segmentsById.get(id) ?? createSegment(id)
+    const last = lastSegment()
+    return last !== undefined && last.id === undefined ? last : createSegment(undefined)
+  }
+  const visibleContent = (segment: RenderSegment) => {
+    const text = changed === undefined || lastSegment() !== segment ? segment.text : `${segment.text}\n\n${changed}`.trim()
+    return sanitizeDiscordContent(text, config.guards)
+  }
   const startTyping = Effect.fn("startDiscordTyping")(function* () {
     if (typingFiber !== undefined) return
     yield* retryDiscord(discord.sendTyping(scope)).pipe(Effect.catch(() => Effect.void))
@@ -72,39 +93,55 @@ export const renderOpencodeEvents = Effect.fn("renderOpencodeEvents")(function*
       status.content = safe
     }
   })
-  const writeChunk = Effect.fn("writeDiscordRenderChunk")(function* (index: number, chunk: string, forceEdit = false) {
-    const existing = posted[index]
+  const writeChunk = Effect.fn("writeDiscordRenderChunk")(function* (
+    segment: RenderSegment,
+    index: number,
+    chunk: string,
+    forceEdit = false
+  ) {
+    const existing = segment.posted[index]
     if (existing === undefined) {
       const created = yield* retryDiscord(discord.postMessage(scope, chunk))
-      posted.push({ id: created.id, content: chunk })
+      segment.posted.push({ id: created.id, content: chunk })
     } else if (forceEdit || existing.content !== chunk) {
       yield* retryDiscord(discord.editMessage(scope, existing.id, chunk))
       existing.content = chunk
     }
   })
-  const flush = Effect.fn("flushDiscordRender")(function* (force = false, forceEdit = false) {
-    const chunks = splitDiscordMarkdown(visibleContent())
+  const flushSegment = Effect.fn("flushDiscordRenderSegment")(function* (segment: RenderSegment, force = false, forceEdit = false) {
+    const chunks = splitDiscordMarkdown(visibleContent(segment))
     if (chunks.length === 0) return
     const now = yield* Clock.currentTimeMillis
-    if (!force && posted.length > 0 && now - lastFlushAt < updateIntervalMs) return
+    if (!force && segment.posted.length > 0 && now - lastFlushAt < updateIntervalMs) return
     for (let index = 0; index < chunks.length; index += 1) {
       const chunk = chunks[index]
       if (chunk === undefined) continue
-      yield* writeChunk(index, chunk, forceEdit)
+      yield* writeChunk(segment, index, chunk, forceEdit)
     }
-    for (let index = posted.length - 1; index >= chunks.length; index -= 1) {
-      const stale = posted[index]
+    for (let index = segment.posted.length - 1; index >= chunks.length; index -= 1) {
+      const stale = segment.posted[index]
       if (stale === undefined) continue
       yield* retryDiscord(discord.deleteMessage(scope, stale.id))
-      posted.splice(index, 1)
+      segment.posted.splice(index, 1)
     }
     lastFlushAt = now
   })
+  const prepareSegment = Effect.fn("prepareDiscordTextSegment")(function* (id: string | undefined) {
+    const previousLast = lastSegment()
+    const segment = getSegment(id)
+    if (changed !== undefined && previousLast !== undefined && previousLast !== segment) yield* flushSegment(previousLast, true)
+    return segment
+  })
+  const flushLastSegment = Effect.fn("flushLastDiscordRenderSegment")(function* (force = false, forceEdit = false) {
+    const segment = lastSegment()
+    if (segment === undefined) return
+    yield* flushSegment(segment, force, forceEdit)
+  })
   const finish = Effect.fn("finishDiscordRender")(function* () {
     if (finished) return
     finished = true
     const wasTyping = yield* stopTyping()
-    yield* flush(true, wasTyping)
+    yield* flushLastSegment(true, wasTyping)
   })
 
   yield* startTyping()
@@ -122,26 +159,32 @@ export const renderOpencodeEvents = Effect.fn("renderOpencodeEvents")(function*
               yield* renderStatus("Tool finished.")
               break
             }
+            case "reasoning-start": {
+              yield* startTyping()
+              break
+            }
             case "idle": {
               yield* finish()
               break
             }
             case "text-delta": {
               yield* stopTyping()
-              answer += event.text
-              yield* flush(posted.length === 0)
+              const segment = yield* prepareSegment(event.id)
+              segment.text += event.text
+              yield* flushSegment(segment, segment.posted.length === 0)
               break
             }
             case "text-snapshot": {
               yield* stopTyping()
-              answer = event.text
-              yield* flush(true)
+              const segment = yield* prepareSegment(event.id)
+              segment.text = event.text
+              yield* flushSegment(segment, true)
               break
             }
             case "changed-files": {
               if (config.streaming.changedFilesSummary && hasChangedFiles(event)) {
                 changed = changedSummary(event)
-                yield* flush(true)
+                yield* flushSegment(lastSegment() ?? createSegment(undefined), true)
               }
               break
             }

package/src/Render/RendererSegments.test.ts

@@ -0,0 +1,64 @@
+import { describe, expect, test } from "bun:test"
+import { Effect, Stream } from "effect"
+import { defaultConfig } from "../Config.ts"
+import { makeMemoryDiscord } from "../Discord/MemoryDiscord.ts"
+import { opencodeEventStream } from "../Opencode/EventMapping.ts"
+import type { DiscordScope } from "../Schema.ts"
+import { renderOpencodeEvents } from "./Renderer.ts"
+
+const scope: DiscordScope = { guildId: "g1", channelId: "c1" }
+
+describe("renderOpencodeEvents text segments", () => {
+  test("preserves separate text parts around hidden reasoning", async () => {
+    const discord = makeMemoryDiscord()
+
+    await Effect.runPromise(
+      renderOpencodeEvents(
+        opencodeEventStream(
+          Stream.fromIterable([
+            { type: "session.next.reasoning.started", properties: { sessionID: "s1", reasoningID: "r1" } },
+            { type: "session.next.text.delta", properties: { sessionID: "s1", textID: "text-1", delta: "First response" } },
+            { type: "session.next.text.ended", properties: { sessionID: "s1", textID: "text-1", text: "First response" } },
+            { type: "session.next.reasoning.started", properties: { sessionID: "s1", reasoningID: "r2" } },
+            { type: "session.next.text.delta", properties: { sessionID: "s1", textID: "text-2", delta: "Second response" } },
+            { type: "session.next.text.ended", properties: { sessionID: "s1", textID: "text-2", text: "Second response" } },
+            { type: "session.idle", properties: { sessionID: "s1" } }
+          ])
+        ),
+        scope,
+        defaultConfig,
+        discord
+      )
+    )
+
+    expect(discord.typingScopes).toEqual([scope, scope])
+    expect(discord.messages).toEqual([
+      { scope, content: "First response" },
+      { scope, content: "Second response" }
+    ])
+    expect(discord.edits).toEqual([])
+    expect(discord.deletes).toEqual([])
+  })
+
+  test("does not delete earlier text-part continuation messages when a later part is shorter", async () => {
+    const discord = makeMemoryDiscord()
+    const long = "a".repeat(2001)
+
+    await Effect.runPromise(
+      renderOpencodeEvents(
+        Stream.fromIterable([
+          { type: "text-delta", id: "text-1", text: long },
+          { type: "text-snapshot", id: "text-1", text: long },
+          { type: "text-delta", id: "text-2", text: "short" },
+          { type: "text-snapshot", id: "text-2", text: "short" }
+        ]),
+        scope,
+        defaultConfig,
+        discord
+      )
+    )
+
+    expect(discord.messages.map((item) => item.content.length)).toEqual([2000, 1, 5])
+    expect(discord.deletes).toEqual([])
+  })
+})

package/src/Schema.ts

@@ -66,8 +66,9 @@ export type ToolRequest = {
 export type ToolResponse = { readonly ok: true; readonly result: unknown } | { readonly ok: false; readonly error: string }
 
 export type OpencodeEvent =
-  | { readonly type: "text-delta"; readonly text: string }
-  | { readonly type: "text-snapshot"; readonly text: string }
+  | { readonly type: "text-delta"; readonly id?: string; readonly text: string }
+  | { readonly type: "text-snapshot"; readonly id?: string; readonly text: string }
+  | { readonly type: "reasoning-start" }
   | { readonly type: "tool-start"; readonly title: string }
   | { readonly type: "tool-end" }
   | { readonly type: "changed-files"; readonly files: number; readonly insertions: number; readonly deletions: number }

package/src/Tools/DiscordBridgeTool.ts

@@ -0,0 +1,44 @@
+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.",
+  args: {
+    action: tool.schema
+      .enum([
+        "followUpMessage",
+        "addReaction",
+        "removeReaction",
+        "fetchHistory",
+        "attachFile",
+        "createThread",
+        "editOwnMessage",
+        "deleteOwnMessage",
+        "postOtherChannel",
+        "pin",
+        "unpin"
+      ])
+      .describe("Discord bridge action to perform."),
+    target: tool.schema
+      .object({
+        guildId: tool.schema.string().optional(),
+        channelId: tool.schema.string().optional(),
+        threadId: tool.schema.string().optional(),
+        messageId: tool.schema.string().optional()
+      })
+      .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.")
+  },
+  async execute(request) {
+    const response = await fetch(loopbackToolUrl, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(request)
+    })
+    const payload: unknown = await response.json()
+    return JSON.stringify(payload, null, 2) ?? String(payload)
+  }
+})

package/src/Tools/Scaffolding.test.ts

@@ -5,15 +5,24 @@ import { join } from "node:path"
 import { ensureDiscordTools, renderDiscordToolFile } from "./Scaffolding.ts"
 
 describe("Discord tool scaffolding", () => {
-  test("renders a generated tool file with the injected loopback URL", () => {
-    const source = renderDiscordToolFile("http://127.0.0.1:8787")
+  test("renders a generated opencode tool file with the injected loopback URL", async () => {
+    const source = await renderDiscordToolFile("http://127.0.0.1:8787")
 
     expect(source).toContain("Generated by opencode-discord-bot")
     expect(source).toContain("http://127.0.0.1:8787/tool")
+    expect(source).toContain('import { tool } from "@opencode-ai/plugin"')
+    expect(source).toContain("export default tool({")
+    expect(source).toContain("args: {")
+    expect(source).toContain(".enum([")
+    expect(source).toContain('"fetchHistory"')
+    expect(source).toContain('"addReaction"')
+    expect(source).toContain(".record(tool.schema.string(), tool.schema.unknown())")
     expect(source).toContain("fetch")
+    expect(source).not.toContain("export const parameters")
+    expect(source).not.toContain("__OPENCODE_DISCORD_BOT_LOOPBACK_URL__")
   })
 
-  test("creates and refreshes only generated files", async () => {
+  test("creates and regenerates the tool file on every run", async () => {
     const projectDir = await mkdtemp(join(tmpdir(), "ocdb-tools-"))
 
     try {
@@ -28,16 +37,18 @@ describe("Discord tool scaffolding", () => {
       expect(await readFile(toolPath, "utf8")).toContain("http://127.0.0.1:9999/tool")
 
       await writeFile(toolPath, "// operator file\n")
-      const skipped = await ensureDiscordTools({ projectDir, bridgePort: 7777, enabled: true, autoInstall: true })
+      const regenerated = await ensureDiscordTools({ projectDir, bridgePort: 7777, enabled: true, autoInstall: true })
 
-      expect(skipped).toEqual([])
-      expect(await readFile(toolPath, "utf8")).toBe("// operator file\n")
+      expect(regenerated).toEqual([toolPath])
+      expect(await readFile(toolPath, "utf8")).toContain("http://127.0.0.1:7777/tool")
+      expect(await readFile(toolPath, "utf8")).not.toContain("// operator file")
 
-      await writeFile(toolPath, `${renderDiscordToolFile("http://127.0.0.1:9999")}\n// operator edit\n`)
-      const edited = await ensureDiscordTools({ projectDir, bridgePort: 6666, enabled: true, autoInstall: true })
+      await writeFile(toolPath, "// Generated by opencode-discord-bot. DO NOT EDIT.\nexport const parameters = {}\n")
+      const migrated = await ensureDiscordTools({ projectDir, bridgePort: 6666, enabled: true, autoInstall: true })
 
-      expect(edited).toEqual([])
-      expect(await readFile(toolPath, "utf8")).toContain("// operator edit")
+      expect(migrated).toEqual([toolPath])
+      expect(await readFile(toolPath, "utf8")).toContain("http://127.0.0.1:6666/tool")
+      expect(await readFile(toolPath, "utf8")).not.toContain("export const parameters")
     } finally {
       await rm(projectDir, { recursive: true, force: true })
     }

package/src/Tools/Scaffolding.ts

@@ -2,7 +2,8 @@ import { mkdir, readFile, writeFile } from "node:fs/promises"
 import { join } from "node:path"
 
 const header = "// Generated by opencode-discord-bot. DO NOT EDIT."
-const loopbackUrlPattern = /const loopbackToolUrl = "(http:\/\/127\.0\.0\.1:\d+)\/tool"/
+const loopbackUrlPlaceholder = "__OPENCODE_DISCORD_BOT_LOOPBACK_URL__"
+const discordToolSourceUrl = new URL("./DiscordBridgeTool.ts", import.meta.url)
 
 export type ToolScaffoldOptions = {
   readonly projectDir: string
@@ -11,50 +12,18 @@ export type ToolScaffoldOptions = {
   readonly autoInstall: boolean
 }
 
-export const renderDiscordToolFile = (loopbackUrl: string): string => `${header}
-const loopbackToolUrl = "${loopbackUrl}/tool"
-
-export const description = "Perform safe Discord bridge actions through the local opencode-discord-bot process."
-
-export const parameters = {
-  type: "object",
-  properties: {
-    action: { type: "string" },
-    target: { type: "object" },
-    args: { type: "object" }
-  },
-  required: ["action", "target", "args"]
-}
-
-export async function execute(input: { action: string; target: object; args: object }) {
-  const response = await fetch(loopbackToolUrl, {
-    method: "POST",
-    headers: { "content-type": "application/json" },
-    body: JSON.stringify(input)
-  })
-  return await response.json()
+export const renderDiscordToolFile = async (loopbackUrl: string): Promise<string> => {
+  const source = await readFile(discordToolSourceUrl, "utf8")
+  return `${header}\n${source.replaceAll(loopbackUrlPlaceholder, loopbackUrl)}`
 }
-`
-
-const generatedLoopbackUrl = (source: string): string | undefined => loopbackUrlPattern.exec(source)?.[1]
 
 export const ensureDiscordTools = async (options: ToolScaffoldOptions): Promise<ReadonlyArray<string>> => {
   if (!options.enabled || !options.autoInstall) return []
   const toolsDir = join(options.projectDir, ".opencode", "tools")
   const toolPath = join(toolsDir, "discord-bridge.ts")
-  const next = renderDiscordToolFile(`http://127.0.0.1:${options.bridgePort}`)
+  const next = await renderDiscordToolFile(`http://127.0.0.1:${options.bridgePort}`)
 
   await mkdir(toolsDir, { recursive: true })
-  try {
-    const current = await readFile(toolPath, "utf8")
-    if (!current.startsWith(header)) return []
-    if (current === next) return [toolPath]
-    const currentLoopbackUrl = generatedLoopbackUrl(current)
-    if (currentLoopbackUrl === undefined || current !== renderDiscordToolFile(currentLoopbackUrl)) return []
-  } catch (error) {
-    if (!(error instanceof Error) || !Reflect.has(error, "code")) throw error
-  }
-
   await writeFile(toolPath, next)
   return [toolPath]
 }