opencode-discord-bot 0.0.8 → 0.0.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-discord-bot",
-  "version": "0.0.8",
+  "version": "0.0.10",
   "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,7 +31,7 @@ describe("context assembly", () => {
       })
     )
 
-    expect(rendered).toContain("[Nick 1 | <@u-1> | 2026-06-05 14:03 UTC | messageId=1]")
+    expect(rendered).toContain("[Nick 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)")
     expect(rendered).toContain("(attachments: screenshot.png [image/png; 12 bytes; https://cdn/a1])")
@@ -51,13 +51,17 @@ 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("(participants)\nNick 1 - <@u-1>\nNick 2 - <@u-2>\nNick 3 - <@u-3>")
+    expect(prompt.text.match(/<@u-3>/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 the participants list to map server nicknames/display names")
+    expect(prompt.text).toContain("When a display name is shared")
     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).toContain("[Nick 3 | 2026-06-05 14:03 UTC | messageId=3]")
     expect(prompt.text).not.toContain("(discord target: guildId=g1 channelId=c1 messageId=3)")
   })
 
@@ -73,11 +77,32 @@ describe("context assembly", () => {
     })
 
     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("[Nick 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("keeps author ids in headers when participant labels collide", () => {
+    const first = makeMessage("1", "from first Sam", {
+      author: { id: "sam-1", displayName: "Sam", nickname: "Sam", isBot: false }
+    })
+    const second = makeMessage("2", "from second Sam", {
+      author: { id: "sam-2", displayName: "Sam", nickname: "Sam", isBot: false }
+    })
+    const prompt = assembleContextPrompt({
+      botUserId: "999",
+      contextMessages: [first],
+      triggerMessage: second,
+      maxMessages: 30,
+      maxChars: 10_000,
+      maxAttachmentBytes: 10_000
+    })
+
+    expect(prompt.text).toContain("(participants)\nSam - <@sam-1>\nSam - <@sam-2>")
+    expect(prompt.text).toContain("[Sam | <@sam-1> | 2026-06-05 14:03 UTC | messageId=1]")
+    expect(prompt.text).toContain("[Sam | <@sam-2> | 2026-06-05 14:03 UTC | messageId=2]")
+  })
+
   test("applies top-N and character budgets without dropping the trigger", () => {
     const trigger = makeMessage("5", "trigger")
     const prompt = assembleContextPrompt({

package/src/Orchestrator/ContextAssembly.ts

@@ -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. 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.`
+  `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 the participants list to map server nicknames/display names to their <@id> values. When a display name is shared, the message header also includes that author's <@id>. 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)
@@ -72,10 +72,53 @@ const attachmentParts = (messages: ReadonlyArray<DiscordMessage>, maxBytes: numb
     })
   )
 
-export const formatDiscordMessage = (message: DiscordMessage, defaultScope?: DiscordScope): string => {
-  const label = message.author.nickname ?? message.author.displayName
+const authorLabel = (message: DiscordMessage): string => message.author.nickname ?? message.author.displayName
+
+type ParticipantsSummary = {
+  readonly text: string | undefined
+  readonly ambiguousAuthorIds: ReadonlySet<string>
+}
+
+const participantsSummary = (messages: ReadonlyArray<DiscordMessage>): ParticipantsSummary => {
+  const participants: Array<{ readonly id: string; readonly label: string }> = []
+  const seenAuthorIds = new Set<string>()
+  const authorIdsByLabel = new Map<string, Set<string>>()
+
+  for (const message of messages) {
+    const id = message.author.id
+    if (seenAuthorIds.has(id)) continue
+    seenAuthorIds.add(id)
+
+    const label = authorLabel(message)
+    participants.push({ id, label })
+
+    const authorIds = authorIdsByLabel.get(label)
+    if (authorIds === undefined) authorIdsByLabel.set(label, new Set([id]))
+    else authorIds.add(id)
+  }
+
+  const ambiguousAuthorIds = new Set<string>()
+  for (const authorIds of authorIdsByLabel.values()) {
+    if (authorIds.size <= 1) continue
+    for (const id of authorIds) ambiguousAuthorIds.add(id)
+  }
+
+  return {
+    ambiguousAuthorIds,
+    text:
+      participants.length === 0 ? undefined : `(participants)\n${participants.map((item) => `${item.label} - <@${item.id}>`).join("\n")}`
+  }
+}
+
+export const formatDiscordMessage = (
+  message: DiscordMessage,
+  defaultScope?: DiscordScope,
+  ambiguousAuthorIds?: ReadonlySet<string>
+): string => {
+  const label = authorLabel(message)
+  const author = ambiguousAuthorIds?.has(message.author.id) === true ? `${label} | <@${message.author.id}>` : label
   const scope = scopeOf(message)
-  const lines = [`[${label} | <@${message.author.id}> | ${timestamp(message.timestamp)} | messageId=${message.id}]`, message.content]
+  const lines = [`[${author} | ${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)
@@ -115,11 +158,14 @@ const renderPrompt = (
   const skippedIds = new Set(skippedMessages.map((message) => message.id))
   const latestMessage = messages.at(-1)
   const defaultScope = latestMessage === undefined ? undefined : scopeOf(latestMessage)
+  const participants = participantsSummary(messages)
   return [
     preamble(botUserId),
+    ...(participants.text === undefined ? [] : [participants.text]),
     ...(defaultScope === undefined ? [] : [defaultScopeSummary(defaultScope)]),
     ...messages.map(
-      (message) => `${skippedIds.has(message.id) ? "(queued intermediate message)\n" : ""}${formatDiscordMessage(message, defaultScope)}`
+      (message) =>
+        `${skippedIds.has(message.id) ? "(queued intermediate message)\n" : ""}${formatDiscordMessage(message, defaultScope, participants.ambiguousAuthorIds)}`
     )
   ].join("\n\n")
 }