@gakr-gakr/discord 0.1.0

package/src/monitor/thread-channel-context.ts

@@ -0,0 +1,112 @@
+import { ChannelType } from "../internal/discord.js";
+import { normalizeDiscordSlug } from "./allow-list.js";
+import {
+  resolveDiscordChannelIdSafe,
+  resolveDiscordChannelInfoSafe,
+  resolveDiscordChannelParentIdSafe,
+} from "./channel-access.js";
+import {
+  resolveDiscordChannelInfo,
+  type DiscordChannelInfo,
+  type DiscordChannelInfoClient,
+} from "./message-utils.js";
+import { resolveDiscordThreadParentInfo } from "./threading.js";
+
+type DiscordThreadLikeChannelContext = {
+  channelType?: ChannelType;
+  isThreadChannel: boolean;
+  channelId: string;
+  channelName?: string;
+  channelSlug: string;
+  parentId?: string;
+  threadParentId?: string;
+  threadParentName?: string;
+  threadParentSlug: string;
+  channelInfo: DiscordChannelInfo | null;
+};
+
+function isDiscordThreadChannelType(type: ChannelType | number | undefined): boolean {
+  return (
+    type === ChannelType.PublicThread ||
+    type === ChannelType.PrivateThread ||
+    type === ChannelType.AnnouncementThread
+  );
+}
+
+function buildFetchedChannelInfo(channel: unknown): DiscordChannelInfo | null {
+  const channelInfo = resolveDiscordChannelInfoSafe(channel);
+  if (channelInfo.type === undefined) {
+    return null;
+  }
+  return {
+    type: channelInfo.type as ChannelType,
+    name: channelInfo.name,
+    topic: channelInfo.topic,
+    parentId: channelInfo.parentId,
+    ownerId: channelInfo.ownerId,
+  };
+}
+
+export async function resolveDiscordThreadLikeChannelContext(params: {
+  client: DiscordChannelInfoClient;
+  channel: unknown;
+  channelIdFallback?: string;
+  channelInfo?: DiscordChannelInfo | null;
+}): Promise<DiscordThreadLikeChannelContext> {
+  const safeChannelInfo = resolveDiscordChannelInfoSafe(params.channel);
+  const channelId = resolveDiscordChannelIdSafe(params.channel) ?? params.channelIdFallback ?? "";
+  const channelInfo =
+    params.channelInfo !== undefined
+      ? params.channelInfo
+      : channelId
+        ? await resolveDiscordChannelInfo(params.client, channelId)
+        : null;
+  const channelType = (safeChannelInfo.type as ChannelType | undefined) ?? channelInfo?.type;
+  const channelName = safeChannelInfo.name ?? channelInfo?.name;
+  const channelSlug = channelName ? normalizeDiscordSlug(channelName) : "";
+  const parentId = resolveDiscordChannelParentIdSafe(params.channel) ?? channelInfo?.parentId;
+  const isThreadChannel = isDiscordThreadChannelType(channelType);
+
+  let threadParentId: string | undefined;
+  let threadParentName: string | undefined;
+  let threadParentSlug = "";
+  if (channelId && isThreadChannel) {
+    const parentInfo = await resolveDiscordThreadParentInfo({
+      client: params.client,
+      threadChannel: {
+        id: channelId,
+        name: channelName,
+        parentId,
+        parent: undefined,
+      },
+      channelInfo,
+    });
+    threadParentId = parentInfo.id;
+    threadParentName = parentInfo.name;
+    threadParentSlug = threadParentName ? normalizeDiscordSlug(threadParentName) : "";
+  }
+
+  return {
+    channelType,
+    isThreadChannel,
+    channelId,
+    channelName,
+    channelSlug,
+    parentId,
+    threadParentId,
+    threadParentName,
+    threadParentSlug,
+    channelInfo,
+  };
+}
+
+export async function resolveFetchedDiscordThreadLikeChannelContext(params: {
+  client: DiscordChannelInfoClient;
+  channel: unknown;
+  channelIdFallback?: string;
+}): Promise<DiscordThreadLikeChannelContext> {
+  return await resolveDiscordThreadLikeChannelContext({
+    ...params,
+    channelInfo: buildFetchedChannelInfo(params.channel),
+  });
+}

package/src/monitor/thread-session-close.ts

@@ -0,0 +1,63 @@
+import type { AutoBotConfig } from "autobot/plugin-sdk/config-contracts";
+import { resolveStorePath, updateSessionStore } from "autobot/plugin-sdk/session-store-runtime";
+import { normalizeOptionalLowercaseString } from "autobot/plugin-sdk/string-coerce-runtime";
+
+/**
+ * Marks every session entry in the store whose key contains {@link threadId}
+ * as "reset" by setting `updatedAt` to 0.
+ *
+ * This mirrors how the daily / idle session reset works: zeroing `updatedAt`
+ * makes `evaluateSessionFreshness` treat the session as stale on the next
+ * inbound message, so the bot starts a fresh conversation without deleting
+ * any on-disk transcript history.
+ */
+export async function closeDiscordThreadSessions(params: {
+  cfg: AutoBotConfig;
+  accountId: string;
+  threadId: string;
+}): Promise<number> {
+  const { cfg, accountId, threadId } = params;
+
+  const normalizedThreadId = normalizeOptionalLowercaseString(threadId) ?? "";
+  if (!normalizedThreadId) {
+    return 0;
+  }
+
+  // Match when the threadId appears as a complete colon-separated segment.
+  // e.g. "999" must be followed by ":" (middle) or end-of-string (final).
+  // Using a regex avoids false-positives where one snowflake is a prefix of
+  // another (e.g. searching for "999" must not match ":99900").
+  //
+  // Session key shapes:
+  //   agent:<agentId>:discord:channel:<threadId>
+  //   agent:<agentId>:discord:channel:<parentId>:thread:<threadId>
+  const segmentRe = new RegExp(`:${normalizedThreadId}(?::|$)`, "i");
+
+  function sessionKeyContainsThreadId(key: string): boolean {
+    return segmentRe.test(key);
+  }
+
+  // Resolve the store file. We pass `accountId` as `agentId` here to mirror
+  // how other Discord subsystems resolve their per-account sessions stores.
+  const storePath = resolveStorePath(cfg.session?.store, { agentId: accountId });
+
+  let resetCount = 0;
+
+  await updateSessionStore(storePath, (store) => {
+    for (const [key, entry] of Object.entries(store)) {
+      if (!entry || !sessionKeyContainsThreadId(key)) {
+        continue;
+      }
+      if (entry.updatedAt === 0) {
+        continue;
+      }
+      // Setting updatedAt to 0 signals that this session is stale.
+      // evaluateSessionFreshness will create a new session on the next message.
+      entry.updatedAt = 0;
+      resetCount += 1;
+    }
+    return resetCount;
+  });
+
+  return resetCount;
+}

package/src/monitor/thread-title.ts

@@ -0,0 +1,181 @@
+import type { AutoBotConfig } from "autobot/plugin-sdk/config-contracts";
+import { logVerbose } from "autobot/plugin-sdk/runtime-env";
+import {
+  completeWithPreparedSimpleCompletionModel,
+  extractAssistantText,
+  prepareSimpleCompletionModelForAgent,
+} from "autobot/plugin-sdk/simple-completion-runtime";
+import { withAbortTimeout } from "./timeouts.js";
+
+const DEFAULT_THREAD_TITLE_TIMEOUT_MS = 10_000;
+const MAX_THREAD_TITLE_SOURCE_CHARS = 600;
+const MAX_THREAD_TITLE_CHANNEL_NAME_CHARS = 120;
+const MAX_THREAD_TITLE_CHANNEL_DESCRIPTION_CHARS = 320;
+// Budget generous enough to cover reasoning-model thinking tokens plus the
+// short text output. Lower values (e.g. 24) starve reasoning models of output
+// capacity: the entire budget is consumed by the thinking block before any
+// text is emitted, so extractAssistantText returns empty and the rename is
+// silently skipped.
+const DISCORD_THREAD_TITLE_MAX_TOKENS = 512;
+const DISCORD_THREAD_TITLE_SYSTEM_PROMPT =
+  "Generate a concise Discord thread title (3-6 words). Return only the title. Use channel context when provided and avoid redundant channel-name words unless needed for clarity.";
+
+export async function generateThreadTitle(params: {
+  cfg: AutoBotConfig;
+  agentId: string;
+  messageText: string;
+  modelRef?: string;
+  channelName?: string;
+  channelDescription?: string;
+  timeoutMs?: number;
+}): Promise<string | null> {
+  const sourceText = params.messageText.trim();
+  if (!sourceText) {
+    return null;
+  }
+
+  const prepared = await prepareSimpleCompletionModelForAgent({
+    cfg: params.cfg,
+    agentId: params.agentId,
+    ...(params.modelRef ? { modelRef: params.modelRef } : {}),
+    allowMissingApiKeyModes: ["aws-sdk"],
+  });
+  if ("error" in prepared) {
+    const modelLabel = prepared.selection
+      ? `${prepared.selection.provider}/${prepared.selection.modelId}`
+      : "unknown";
+    logVerbose(`thread-title: ${prepared.error} (agent=${params.agentId}, model=${modelLabel})`);
+    return null;
+  }
+
+  try {
+    const promptText = truncateThreadTitleSourceText(sourceText);
+    const userMessage = buildThreadTitleUserMessage({
+      sourceText: promptText,
+      channelName: params.channelName,
+      channelDescription: params.channelDescription,
+    });
+    const timeoutMs = resolveThreadTitleTimeoutMs(params.timeoutMs);
+    const response = await completeThreadTitle({
+      model: prepared.model,
+      auth: prepared.auth,
+      userMessage,
+      timeoutMs,
+    });
+    const generated = normalizeGeneratedThreadTitle(extractAssistantText(response));
+    return generated || null;
+  } catch (err) {
+    logVerbose(`thread-title: title generation failed for agent ${params.agentId}: ${String(err)}`);
+    return null;
+  }
+}
+
+async function completeThreadTitle(params: {
+  model: Parameters<typeof completeWithPreparedSimpleCompletionModel>[0]["model"];
+  auth: Parameters<typeof completeWithPreparedSimpleCompletionModel>[0]["auth"];
+  userMessage: string;
+  timeoutMs: number;
+}) {
+  return await withAbortTimeout({
+    timeoutMs: params.timeoutMs,
+    createTimeoutError: () => new Error(`thread-title timed out after ${params.timeoutMs}ms`),
+    run: async (signal) =>
+      await completeWithPreparedSimpleCompletionModel({
+        model: params.model,
+        auth: params.auth,
+        context: {
+          systemPrompt: DISCORD_THREAD_TITLE_SYSTEM_PROMPT,
+          messages: [
+            {
+              role: "user",
+              content: params.userMessage,
+              timestamp: Date.now(),
+            },
+          ],
+        },
+        options: {
+          maxTokens: DISCORD_THREAD_TITLE_MAX_TOKENS,
+          signal,
+        },
+      }),
+  });
+}
+
+function buildThreadTitleUserMessage(params: {
+  sourceText: string;
+  channelName?: string;
+  channelDescription?: string;
+}): string {
+  const channelName = normalizeTitleContextField(
+    params.channelName,
+    MAX_THREAD_TITLE_CHANNEL_NAME_CHARS,
+  );
+  const channelDescription = normalizeTitleContextField(
+    params.channelDescription,
+    MAX_THREAD_TITLE_CHANNEL_DESCRIPTION_CHARS,
+  );
+  const messageLines: string[] = [];
+  if (channelName) {
+    messageLines.push(`Channel: ${channelName}`);
+  }
+  if (channelDescription) {
+    messageLines.push(`Channel description: ${channelDescription}`);
+  }
+  messageLines.push(`Message:\n${params.sourceText}`);
+  return messageLines.join("\n\n");
+}
+
+function truncateThreadTitleSourceText(sourceText: string): string {
+  if (sourceText.length <= MAX_THREAD_TITLE_SOURCE_CHARS) {
+    return sourceText;
+  }
+  return `${sourceText.slice(0, MAX_THREAD_TITLE_SOURCE_CHARS)}...`;
+}
+
+function resolveThreadTitleTimeoutMs(timeoutMs: number | undefined): number {
+  return Math.max(100, Math.floor(timeoutMs ?? DEFAULT_THREAD_TITLE_TIMEOUT_MS));
+}
+
+export function normalizeGeneratedThreadTitle(raw: string): string {
+  const lines = raw.replace(/\r/g, "").split("\n");
+  let firstLine = "";
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      continue;
+    }
+    if (!firstLine && trimmed.startsWith("```")) {
+      continue;
+    }
+    firstLine = trimmed;
+    break;
+  }
+  return stripThreadTitleWrappers(firstLine);
+}
+
+function stripThreadTitleWrappers(raw: string): string {
+  let current = raw.trim();
+  let previous = "";
+  while (current && current !== previous) {
+    previous = current;
+    current = current.replace(/^["'`]+|["'`]+$/g, "").trim();
+    current = current.replace(/^\*\*(.+)\*\*$/u, "$1").trim();
+    current = current.replace(/^__(.+)__$/u, "$1").trim();
+    current = current.replace(/^\*(.+)\*$/u, "$1").trim();
+    current = current.replace(/^_(.+)_$/u, "$1").trim();
+    current = current.replace(/^~~(.+)~~$/u, "$1").trim();
+  }
+  return current;
+}
+
+function normalizeTitleContextField(raw: string | undefined, maxChars: number): string | undefined {
+  const value = raw?.trim();
+  if (!value) {
+    return undefined;
+  }
+  const singleLine = value.replace(/\s+/g, " ");
+  if (singleLine.length <= maxChars) {
+    return singleLine;
+  }
+  return `${singleLine.slice(0, maxChars)}...`;
+}

package/src/monitor/threading.auto-thread.ts

@@ -0,0 +1,287 @@
+import type { AutoBotConfig, ReplyToMode } from "autobot/plugin-sdk/config-contracts";
+import { resolveChannelModelOverride } from "autobot/plugin-sdk/model-session-runtime";
+import { buildAgentSessionKey } from "autobot/plugin-sdk/routing";
+import { logVerbose } from "autobot/plugin-sdk/runtime-env";
+import {
+  normalizeOptionalString,
+  normalizeOptionalStringifiedId,
+} from "autobot/plugin-sdk/string-coerce-runtime";
+import {
+  ChannelType,
+  createThread,
+  editChannel,
+  getChannelMessage,
+  type Client,
+} from "../internal/discord.js";
+import { resolveDiscordMessageChannelId } from "./message-utils.js";
+import { generateThreadTitle } from "./thread-title.js";
+import { resolveDiscordReplyDeliveryPlan, sanitizeDiscordThreadName } from "./threading.starter.js";
+import type {
+  DiscordAutoThreadContext,
+  DiscordAutoThreadReplyPlan,
+  DiscordMessageEvent,
+  MaybeCreateDiscordAutoThreadParams,
+} from "./threading.types.js";
+
+function resolveTrimmedDiscordMessageChannelId(params: {
+  message: DiscordMessageEvent["message"];
+  messageChannelId?: string;
+}) {
+  return (
+    params.messageChannelId ||
+    resolveDiscordMessageChannelId({
+      message: params.message,
+    })
+  ).trim();
+}
+
+export function resolveDiscordAutoThreadContext(params: {
+  agentId: string;
+  channel: string;
+  messageChannelId: string;
+  createdThreadId?: string | null;
+  parentInheritanceEnabled?: boolean;
+}): DiscordAutoThreadContext | null {
+  const createdThreadId = normalizeOptionalStringifiedId(params.createdThreadId) ?? "";
+  if (!createdThreadId) {
+    return null;
+  }
+  const messageChannelId = normalizeOptionalString(params.messageChannelId) ?? "";
+  if (!messageChannelId) {
+    return null;
+  }
+
+  const threadSessionKey = buildAgentSessionKey({
+    agentId: params.agentId,
+    channel: params.channel,
+    peer: { kind: "channel", id: createdThreadId },
+  });
+  const parentSessionKey = buildAgentSessionKey({
+    agentId: params.agentId,
+    channel: params.channel,
+    peer: { kind: "channel", id: messageChannelId },
+  });
+
+  return {
+    createdThreadId,
+    From: `${params.channel}:channel:${createdThreadId}`,
+    To: `channel:${createdThreadId}`,
+    OriginatingTo: `channel:${createdThreadId}`,
+    SessionKey: threadSessionKey,
+    ModelParentSessionKey: parentSessionKey,
+    ...(params.parentInheritanceEnabled === true ? { ParentSessionKey: parentSessionKey } : {}),
+  };
+}
+
+export async function resolveDiscordAutoThreadReplyPlan(
+  params: MaybeCreateDiscordAutoThreadParams & {
+    replyToMode: ReplyToMode;
+    agentId: string;
+    channel: string;
+    cfg: AutoBotConfig;
+    threadParentInheritanceEnabled?: boolean;
+  },
+): Promise<DiscordAutoThreadReplyPlan> {
+  const messageChannelId = resolveTrimmedDiscordMessageChannelId(params);
+  const targetChannelId = params.threadChannel?.id ?? (messageChannelId || "unknown");
+  const originalReplyTarget = `channel:${targetChannelId}`;
+  const createdThreadId = await maybeCreateDiscordAutoThread({
+    client: params.client,
+    message: params.message,
+    messageChannelId: messageChannelId || undefined,
+    channel: params.channel,
+    isGuildMessage: params.isGuildMessage,
+    channelConfig: params.channelConfig,
+    threadChannel: params.threadChannel,
+    channelType: params.channelType,
+    channelName: params.channelName,
+    channelDescription: params.channelDescription,
+    baseText: params.baseText,
+    combinedBody: params.combinedBody,
+    cfg: params.cfg,
+    agentId: params.agentId,
+  });
+  const deliveryPlan = resolveDiscordReplyDeliveryPlan({
+    replyTarget: originalReplyTarget,
+    replyToMode: params.replyToMode,
+    messageId: params.message.id,
+    threadChannel: params.threadChannel,
+    createdThreadId,
+  });
+  const autoThreadContext = params.isGuildMessage
+    ? resolveDiscordAutoThreadContext({
+        agentId: params.agentId,
+        channel: params.channel,
+        messageChannelId,
+        createdThreadId,
+        parentInheritanceEnabled: params.threadParentInheritanceEnabled,
+      })
+    : null;
+  return { ...deliveryPlan, createdThreadId, autoThreadContext };
+}
+
+export async function maybeCreateDiscordAutoThread(
+  params: MaybeCreateDiscordAutoThreadParams,
+): Promise<string | undefined> {
+  if (!params.isGuildMessage) {
+    return undefined;
+  }
+  if (!params.channelConfig?.autoThread) {
+    return undefined;
+  }
+  if (params.threadChannel) {
+    return undefined;
+  }
+  if (
+    params.channelType === ChannelType.GuildForum ||
+    params.channelType === ChannelType.GuildMedia ||
+    params.channelType === ChannelType.GuildVoice ||
+    params.channelType === ChannelType.GuildStageVoice
+  ) {
+    return undefined;
+  }
+
+  const messageChannelId = resolveTrimmedDiscordMessageChannelId(params);
+  if (!messageChannelId) {
+    return undefined;
+  }
+  try {
+    const rawThreadSource = params.baseText || params.combinedBody || "Thread";
+    const threadName = sanitizeDiscordThreadName(rawThreadSource, params.message.id);
+    const archiveDuration = params.channelConfig?.autoArchiveDuration
+      ? Number(params.channelConfig.autoArchiveDuration)
+      : 60;
+
+    const created = await createThread<{ id?: string }>(
+      params.client.rest,
+      messageChannelId,
+      {
+        body: {
+          name: threadName,
+          auto_archive_duration: archiveDuration,
+        },
+      },
+      params.message.id,
+    );
+    const createdId = created?.id || "";
+    if (
+      createdId &&
+      params.channelConfig?.autoThreadName === "generated" &&
+      params.cfg &&
+      params.agentId
+    ) {
+      const modelRef = resolveDiscordThreadTitleModelRef({
+        cfg: params.cfg,
+        channel: params.channel,
+        agentId: params.agentId,
+        threadId: createdId,
+        messageChannelId,
+        channelName: params.channelName,
+      });
+      void maybeRenameDiscordAutoThread({
+        client: params.client,
+        threadId: createdId,
+        currentName: threadName,
+        fallbackId: params.message.id,
+        sourceText: rawThreadSource,
+        modelRef,
+        channelName: params.channelName,
+        channelDescription: params.channelDescription,
+        cfg: params.cfg,
+        agentId: params.agentId,
+      });
+    }
+    return createdId || undefined;
+  } catch (err) {
+    logVerbose(
+      `discord: autoThread creation failed for ${messageChannelId}/${params.message.id}: ${String(err)}`,
+    );
+    try {
+      const msg = (await getChannelMessage(
+        params.client.rest,
+        messageChannelId,
+        params.message.id,
+      )) as {
+        thread?: { id?: string };
+      };
+      const existingThreadId = msg?.thread?.id || "";
+      if (existingThreadId) {
+        logVerbose(
+          `discord: autoThread reusing existing thread ${existingThreadId} on ${messageChannelId}/${params.message.id}`,
+        );
+        return existingThreadId;
+      }
+    } catch {
+      // If the refetch also fails, fall through to return undefined.
+    }
+    return undefined;
+  }
+}
+
+function resolveDiscordThreadTitleModelRef(params: {
+  cfg: AutoBotConfig;
+  channel?: string;
+  agentId: string;
+  threadId: string;
+  messageChannelId: string;
+  channelName?: string;
+}): string | undefined {
+  const channel = params.channel?.trim();
+  if (!channel) {
+    return undefined;
+  }
+  const parentSessionKey = buildAgentSessionKey({
+    agentId: params.agentId,
+    channel,
+    peer: { kind: "channel", id: params.messageChannelId },
+  });
+  const channelLabel = params.channelName?.trim();
+  const groupChannel = channelLabel ? `#${channelLabel}` : undefined;
+  const channelOverride = resolveChannelModelOverride({
+    cfg: params.cfg,
+    channel,
+    groupId: params.threadId,
+    groupChatType: "channel",
+    groupChannel,
+    groupSubject: groupChannel,
+    parentSessionKey,
+  });
+  return channelOverride?.model;
+}
+
+async function maybeRenameDiscordAutoThread(params: {
+  client: Client;
+  threadId: string;
+  currentName: string;
+  fallbackId: string;
+  sourceText: string;
+  modelRef?: string;
+  channelName?: string;
+  channelDescription?: string;
+  cfg: AutoBotConfig;
+  agentId: string;
+}): Promise<void> {
+  try {
+    const fallbackName = sanitizeDiscordThreadName("", params.fallbackId);
+    const generated = await generateThreadTitle({
+      cfg: params.cfg,
+      agentId: params.agentId,
+      messageText: params.sourceText,
+      modelRef: params.modelRef,
+      channelName: params.channelName,
+      channelDescription: params.channelDescription,
+    });
+    if (!generated) {
+      return;
+    }
+    const nextName = sanitizeDiscordThreadName(generated, params.fallbackId);
+    if (!nextName || nextName === params.currentName || nextName === fallbackName) {
+      return;
+    }
+    await editChannel(params.client.rest, params.threadId, {
+      body: { name: nextName },
+    });
+  } catch (err) {
+    logVerbose(`discord: autoThread rename failed for ${params.threadId}: ${String(err)}`);
+  }
+}

package/src/monitor/threading.cache.ts

@@ -0,0 +1,45 @@
+import type { DiscordThreadStarter } from "./threading.types.js";
+
+type DiscordThreadStarterCacheEntry = {
+  value: DiscordThreadStarter;
+  updatedAt: number;
+};
+
+const DISCORD_THREAD_STARTER_CACHE_TTL_MS = 5 * 60 * 1000;
+const DISCORD_THREAD_STARTER_CACHE_MAX = 500;
+
+const DISCORD_THREAD_STARTER_CACHE = new Map<string, DiscordThreadStarterCacheEntry>();
+
+export function resetDiscordThreadStarterCacheForTest() {
+  DISCORD_THREAD_STARTER_CACHE.clear();
+}
+
+export function getCachedThreadStarter(key: string, now: number): DiscordThreadStarter | undefined {
+  const entry = DISCORD_THREAD_STARTER_CACHE.get(key);
+  if (!entry) {
+    return undefined;
+  }
+  if (now - entry.updatedAt > DISCORD_THREAD_STARTER_CACHE_TTL_MS) {
+    DISCORD_THREAD_STARTER_CACHE.delete(key);
+    return undefined;
+  }
+  DISCORD_THREAD_STARTER_CACHE.delete(key);
+  DISCORD_THREAD_STARTER_CACHE.set(key, { ...entry, updatedAt: now });
+  return entry.value;
+}
+
+export function setCachedThreadStarter(
+  key: string,
+  value: DiscordThreadStarter,
+  now: number,
+): void {
+  DISCORD_THREAD_STARTER_CACHE.delete(key);
+  DISCORD_THREAD_STARTER_CACHE.set(key, { value, updatedAt: now });
+  while (DISCORD_THREAD_STARTER_CACHE.size > DISCORD_THREAD_STARTER_CACHE_MAX) {
+    const iter = DISCORD_THREAD_STARTER_CACHE.keys().next();
+    if (iter.done) {
+      break;
+    }
+    DISCORD_THREAD_STARTER_CACHE.delete(iter.value);
+  }
+}