opencode-discord-bot 0.0.7 → 0.0.9

package/package.json

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

package/src/Discord/ChatSdkDiscord.test.ts

@@ -99,7 +99,7 @@ describe("makeChatSdkDiscord", () => {
         guildId: "g1",
         channelId: "c1",
         threadId: "t1",
-        author: { id: "u1", displayName: "Alice", nickname: "alice", isBot: false },
+        author: { id: "u1", displayName: "Alice", isBot: false },
         content: "hello <@999>",
         timestamp: "2026-06-05T14:03:00.000Z",
         mentions: ["999"],
@@ -149,6 +149,56 @@ describe("makeChatSdkDiscord", () => {
 })
 
 describe("makeChatSdkDiscord REST operations", () => {
+  test("resolves server nicknames for fetched message authors and caches them", async () => {
+    const adapter = new FakeDiscordAdapter()
+    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(
+          new Response(JSON.stringify({ nick: "Ali the Great" }), { status: 200, headers: { "content-type": "application/json" } })
+        )
+      },
+      { preconnect: originalFetch.preconnect }
+    )
+    globalThis.fetch = fakeFetch
+
+    try {
+      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
+    }
+
+    expect(requests).toEqual(["https://discord.test/api/guilds/g1/members/u1"])
+  })
+
+  test("omits server nickname when the member lookup fails", async () => {
+    const adapter = new FakeDiscordAdapter()
+    const originalFetch = globalThis.fetch
+    const fakeFetch: typeof fetch = Object.assign(() => Promise.resolve(new Response("missing", { status: 404 })), {
+      preconnect: originalFetch.preconnect
+    })
+    globalThis.fetch = fakeFetch
+
+    try {
+      const discord = makeChatSdkDiscord(adapter, { botToken: "token", apiUrl: "https://discord.test/api" })
+
+      const context = await Effect.runPromise(discord.fetchContext(scope, 30))
+
+      expect(context[0]?.author).toEqual({ id: "u1", displayName: "Alice", isBot: false })
+    } finally {
+      globalThis.fetch = originalFetch
+    }
+  })
+
   test("routes deletes and raw REST adapter gaps", async () => {
     const adapter = new FakeDiscordAdapter()
     const requests: Array<readonly [string, RequestInit]> = []

package/src/Discord/ChatSdkDiscord.ts

@@ -23,6 +23,15 @@ type LiveDiscordOptions = {
   readonly publicKey?: string
 }
 
+type NicknameCacheEntry = {
+  readonly nickname: string | undefined
+  readonly expiresAt: number
+}
+
+const defaultNicknameCacheTtlMs = 7 * 24 * 60 * 60 * 1000
+const nicknameLookupFailureCacheTtlMs = 5 * 60 * 1000
+const nicknameResolveConcurrency = 5
+
 const threadIdFromScope = (adapter: ChatDiscordAdapter, scope: DiscordScope): string =>
   adapter.encodeThreadId({
     guildId: scope.guildId,
@@ -44,7 +53,7 @@ const attachments = (message: Message<unknown>): ReadonlyArray<DiscordAttachment
     url: item.url ?? ""
   }))
 
-const fromChatMessage = (scope: DiscordScope, message: Message<unknown>): DiscordMessage => ({
+const fromChatMessage = (scope: DiscordScope, message: Message<unknown>, nickname?: string | undefined): DiscordMessage => ({
   id: message.id,
   guildId: scope.guildId,
   channelId: scope.channelId,
@@ -52,7 +61,7 @@ const fromChatMessage = (scope: DiscordScope, message: Message<unknown>): Discor
   author: {
     id: message.author.userId,
     displayName: message.author.fullName,
-    nickname: message.author.userName,
+    ...(nickname === undefined ? {} : { nickname }),
     isBot: message.author.isBot === true
   },
   content: message.text,
@@ -102,75 +111,137 @@ const retryAfterHeader = (response: Response) => {
 type RawDiscordOptions = {
   readonly botToken: string
   readonly apiUrl?: string | undefined
+  readonly nicknameCacheTtlMs?: number | undefined
 }
 
-const rawDiscord = (options: RawDiscordOptions | undefined, path: string, init: RequestInit): Effect.Effect<unknown, DiscordError> =>
-  tryAdapter(async () => {
-    if (options === undefined) throw new Error("Discord adapter does not expose this operation")
-    const response = await fetch(`${options.apiUrl ?? "https://discord.com/api/v10"}${path}`, {
-      ...init,
-      headers: {
-        authorization: `Bot ${options.botToken}`,
-        "content-type": "application/json",
-        ...init.headers
-      }
-    })
-    if (!response.ok)
-      throw new DiscordError({
-        message: `Discord REST ${response.status}: ${await response.text()}`,
-        retryAfter: retryAfterHeader(response)
-      })
-    if (response.status === 204) return {}
-    return await response.json()
+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
+  return typeof nick === "string" && nick.length > 0 ? nick : undefined
+}
 
 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 () => {
-      const threadId = threadIdFromScope(adapter, scope)
-      const result = await adapter.fetchMessages(threadId, { limit })
-      return result.messages.map((message) => fromChatMessage(scope, message))
-    }),
-  fetchHistory: (scope, limit) =>
+export const makeChatSdkDiscord = (adapter: ChatDiscordAdapter, raw: RawDiscordOptions | undefined = undefined): DiscordService => {
+  const nicknameCache = new Map<string, NicknameCacheEntry>()
+  const nicknameInflight = new Map<string, Promise<string | undefined>>()
+  const nicknameCacheTtlMs =
+    raw?.nicknameCacheTtlMs !== undefined && Number.isFinite(raw.nicknameCacheTtlMs) && raw.nicknameCacheTtlMs > 0
+      ? raw.nicknameCacheTtlMs
+      : defaultNicknameCacheTtlMs
+
+  const cacheNickname = (key: string, nickname: string | undefined, ttlMs = nicknameCacheTtlMs): void => {
+    nicknameCache.set(key, { nickname, expiresAt: Date.now() + ttlMs })
+  }
+
+  const resolveNickname = async (scope: DiscordScope, userId: string): Promise<string | undefined> => {
+    if (raw === undefined || scope.guildId === "@me") return undefined
+    const key = `${scope.guildId}:${userId}`
+    const cached = nicknameCache.get(key)
+    if (cached !== undefined && cached.expiresAt > Date.now()) return cached.nickname
+
+    const inflight = nicknameInflight.get(key)
+    if (inflight !== undefined) return inflight
+
+    const request = rawDiscordRequest(raw, `/guilds/${scope.guildId}/members/${userId}`, { method: "GET" })
+      .then(memberNickname)
+      .then((nickname) => {
+        cacheNickname(key, nickname)
+        return nickname
+      })
+      .catch(() => {
+        cacheNickname(key, undefined, nicknameLookupFailureCacheTtlMs)
+        return undefined
+      })
+      .finally(() => nicknameInflight.delete(key))
+    nicknameInflight.set(key, request)
+    return request
+  }
+
+  const resolveNicknames = async (
+    scope: DiscordScope,
+    messages: ReadonlyArray<Message<unknown>>
+  ): Promise<ReadonlyMap<string, string | undefined>> => {
+    if (raw === undefined || scope.guildId === "@me") return new Map()
+    const pending = [...new Set(messages.map((message) => message.author.userId))]
+    const resolved = new Map<string, string | undefined>()
+    const workers = Array.from({ length: Math.min(nicknameResolveConcurrency, pending.length) }, async () => {
+      while (true) {
+        const userId = pending.shift()
+        if (userId === undefined) return
+        resolved.set(userId, await resolveNickname(scope, userId))
+      }
+    })
+    await Promise.all(workers)
+    return resolved
+  }
+
+  const fetchMessages = (scope: DiscordScope, limit: number) =>
     tryAdapter(async () => {
       const threadId = threadIdFromScope(adapter, scope)
       const result = await adapter.fetchMessages(threadId, { limit })
-      return result.messages.map((message) => fromChatMessage(scope, message))
-    }),
-  sendTyping: (scope) => tryAdapter(() => adapter.startTyping(threadIdFromScope(adapter, scope))).pipe(Effect.asVoid),
-  postMessage: (scope, content) =>
-    tryAdapter(async () => {
-      const result = await adapter.postMessage(threadIdFromScope(adapter, scope), normalizeMentionsForChatAdapter(content))
-      return { id: result.id }
-    }),
-  editMessage: (scope, messageId, content) =>
-    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) =>
-    tryAdapter(() => adapter.addReaction(threadIdFromScope(adapter, scope), messageId, emoji)).pipe(Effect.asVoid),
-  removeReaction: (scope, messageId, emoji) =>
-    tryAdapter(() => adapter.removeReaction(threadIdFromScope(adapter, scope), messageId, emoji)).pipe(Effect.asVoid),
-  attachFile: (scope, path) =>
-    tryAdapter(async () => {
-      const file: PostableRaw = { raw: "", files: [{ filename: basename(path), data: await readFile(path) }] }
-      const result = await adapter.postMessage(threadIdFromScope(adapter, scope), file)
-      return { path: result.id }
-    }),
-  createThread: (scope, name) =>
-    rawDiscord(raw, `/channels/${scope.channelId}/threads`, {
-      method: "POST",
-      body: JSON.stringify({ name, type: 11 })
-    }).pipe(Effect.map((data) => ({ id: isRecord(data) && typeof data.id === "string" ? data.id : "" }))),
-  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 nicknames = await resolveNicknames(scope, result.messages)
+      return result.messages.map((message) => fromChatMessage(scope, message, nicknames.get(message.author.userId)))
+    })
+
+  return {
+    fetchContext: fetchMessages,
+    fetchHistory: fetchMessages,
+    sendTyping: (scope) => tryAdapter(() => adapter.startTyping(threadIdFromScope(adapter, scope))).pipe(Effect.asVoid),
+    postMessage: (scope, content) =>
+      tryAdapter(async () => {
+        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, normalizeMentionsForChatAdapter(content))).pipe(
+        Effect.asVoid
+      ),
+    deleteMessage: (scope, messageId) =>
+      tryAdapter(() => adapter.deleteMessage(threadIdFromScope(adapter, scope), messageId)).pipe(Effect.asVoid),
+    addReaction: (scope, messageId, emoji) =>
+      tryAdapter(() => adapter.addReaction(threadIdFromScope(adapter, scope), messageId, emoji)).pipe(Effect.asVoid),
+    removeReaction: (scope, messageId, emoji) =>
+      tryAdapter(() => adapter.removeReaction(threadIdFromScope(adapter, scope), messageId, emoji)).pipe(Effect.asVoid),
+    attachFile: (scope, path) =>
+      tryAdapter(async () => {
+        const file: PostableRaw = { raw: "", files: [{ filename: basename(path), data: await readFile(path) }] }
+        const result = await adapter.postMessage(threadIdFromScope(adapter, scope), file)
+        return { path: result.id }
+      }),
+    createThread: (scope, name) =>
+      rawDiscord(raw, `/channels/${scope.channelId}/threads`, {
+        method: "POST",
+        body: JSON.stringify({ name, type: 11 })
+      }).pipe(Effect.map((data) => ({ id: isRecord(data) && typeof data.id === "string" ? data.id : "" }))),
+    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)
+  }
+}
 
 export const makeLiveChatSdkDiscord = (options: LiveDiscordOptions): DiscordService =>
   makeChatSdkDiscord(

package/src/Orchestrator/ContextAssembly.test.ts

@@ -31,9 +31,9 @@ describe("context assembly", () => {
       })
     )
 
-    expect(rendered).toContain("[Nick 1 | <@u-1> | 2026-06-05 14:03 UTC]")
+    expect(rendered).toContain("[Nick 1 | <@u-1> | 2026-06-05 14:03 UTC | messageId=1]")
     expect(rendered).toContain("Can you refactor this?")
-    expect(rendered).toContain("(discord target: guildId=g1 channelId=c1 messageId=1)")
+    expect(rendered).toContain("(discord target: guildId=g1 channelId=c1)")
     expect(rendered).toContain("(attachments: screenshot.png [image/png; 12 bytes; https://cdn/a1])")
     expect(rendered).toContain("(reactions: thumbs_up x2, tada x1)")
   })
@@ -54,8 +54,28 @@ describe("context assembly", () => {
     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 non-message bridge tools")
+    expect(prompt.text).toContain("combine the discord default scope or message target override with the header messageId")
     expect(prompt.text).toContain("Do not emit @everyone, @here, or role pings")
+    expect(prompt.text).toContain("(discord default scope: guildId=g1 channelId=c1)")
+    expect(prompt.text).toContain("[Nick 3 | <@u-3> | 2026-06-05 14:03 UTC | messageId=3]")
+    expect(prompt.text).not.toContain("(discord target: guildId=g1 channelId=c1 messageId=3)")
+  })
+
+  test("renders a target override when a message scope differs from the default", () => {
+    const trigger = makeMessage("2", "trigger")
+    const prompt = assembleContextPrompt({
+      botUserId: "999",
+      contextMessages: [makeMessage("1", "different channel", { channelId: "c2", threadId: "t2" })],
+      triggerMessage: trigger,
+      maxMessages: 30,
+      maxChars: 10_000,
+      maxAttachmentBytes: 10_000
+    })
+
+    expect(prompt.text).toContain("(discord default scope: guildId=g1 channelId=c1)")
+    expect(prompt.text).toContain("[Nick 1 | <@u-1> | 2026-06-05 14:03 UTC | messageId=1]")
+    expect(prompt.text).toContain("(discord target: guildId=g1 channelId=c2 threadId=t2)")
+    expect(prompt.text).not.toContain("(discord target: guildId=g1 channelId=c1)")
   })
 
   test("applies top-N and character budgets without dropping the trigger", () => {

package/src/Orchestrator/ContextAssembly.ts

@@ -1,5 +1,5 @@
 import type { OpencodePromptFilePart } from "../Opencode/OpencodePort.ts"
-import type { DiscordMessage } from "../Schema.ts"
+import type { DiscordMessage, DiscordScope } from "../Schema.ts"
 
 export type ContextPrompt = {
   readonly text: string
@@ -18,7 +18,7 @@ type ContextInput = {
 }
 
 const preamble = (botUserId: string) =>
-  `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.`
+  `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. For non-message bridge tools, combine the discord default scope or message target override with the header messageId. Do not emit @everyone, @here, or role pings unless explicitly allowed.`
 
 const timestamp = (value: string): string => {
   const date = new Date(value)
@@ -42,11 +42,24 @@ const reactionSummary = (message: DiscordMessage): string | undefined => {
   return `(reactions: ${message.reactions.map((item) => `${item.emoji} x${item.count}`).join(", ")})`
 }
 
-const targetSummary = (message: DiscordMessage): string => {
-  const thread = message.threadId === undefined ? "" : ` threadId=${message.threadId}`
-  return `(discord target: guildId=${message.guildId} channelId=${message.channelId}${thread} messageId=${message.id})`
+const scopeOf = (message: DiscordMessage): DiscordScope => ({
+  guildId: message.guildId,
+  channelId: message.channelId,
+  ...(message.threadId === undefined ? {} : { threadId: message.threadId })
+})
+
+const sameScope = (left: DiscordScope, right: DiscordScope): boolean =>
+  left.guildId === right.guildId && left.channelId === right.channelId && left.threadId === right.threadId
+
+const scopeSummary = (scope: DiscordScope): string => {
+  const thread = scope.threadId === undefined ? "" : ` threadId=${scope.threadId}`
+  return `guildId=${scope.guildId} channelId=${scope.channelId}${thread}`
 }
 
+const defaultScopeSummary = (scope: DiscordScope): string => `(discord default scope: ${scopeSummary(scope)})`
+
+const targetSummary = (scope: DiscordScope): string => `(discord target: ${scopeSummary(scope)})`
+
 const isForwardableMime = (mime: string): boolean =>
   mime.startsWith("image/") || mime === "application/pdf" || mime.startsWith("audio/") || mime.startsWith("text/")
 
@@ -59,10 +72,11 @@ const attachmentParts = (messages: ReadonlyArray<DiscordMessage>, maxBytes: numb
     })
   )
 
-export const formatDiscordMessage = (message: DiscordMessage): string => {
+export const formatDiscordMessage = (message: DiscordMessage, defaultScope?: DiscordScope): string => {
   const label = message.author.nickname ?? message.author.displayName
-  const lines = [`[${label} | <@${message.author.id}> | ${timestamp(message.timestamp)}]`, message.content]
-  lines.push(targetSummary(message))
+  const scope = scopeOf(message)
+  const lines = [`[${label} | <@${message.author.id}> | ${timestamp(message.timestamp)} | messageId=${message.id}]`, message.content]
+  if (defaultScope === undefined || !sameScope(scope, defaultScope)) lines.push(targetSummary(scope))
   const attachments = attachmentSummary(message)
   const reactions = reactionSummary(message)
   if (attachments !== undefined) lines.push(attachments)
@@ -99,9 +113,14 @@ const renderPrompt = (
   skippedMessages: ReadonlyArray<DiscordMessage>
 ): string => {
   const skippedIds = new Set(skippedMessages.map((message) => message.id))
+  const latestMessage = messages.at(-1)
+  const defaultScope = latestMessage === undefined ? undefined : scopeOf(latestMessage)
   return [
     preamble(botUserId),
-    ...messages.map((message) => `${skippedIds.has(message.id) ? "(queued intermediate message)\n" : ""}${formatDiscordMessage(message)}`)
+    ...(defaultScope === undefined ? [] : [defaultScopeSummary(defaultScope)]),
+    ...messages.map(
+      (message) => `${skippedIds.has(message.id) ? "(queued intermediate message)\n" : ""}${formatDiscordMessage(message, defaultScope)}`
+    )
   ].join("\n\n")
 }