@gakr-gakr/discord 0.1.0

package/src/monitor/threading.starter.ts

@@ -0,0 +1,288 @@
+import type { ReplyToMode } from "autobot/plugin-sdk/config-contracts";
+import { createReplyReferencePlanner } from "autobot/plugin-sdk/reply-reference";
+import { normalizeOptionalString } from "autobot/plugin-sdk/string-coerce-runtime";
+import { truncateUtf16Safe } from "autobot/plugin-sdk/text-utility-runtime";
+import { ChannelType, getChannelMessage, type Client } from "../internal/discord.js";
+import {
+  resolveDiscordChannelIdSafe,
+  resolveDiscordChannelNameSafe,
+  resolveDiscordChannelParentIdSafe,
+  resolveDiscordChannelParentSafe,
+} from "./channel-access.js";
+import {
+  resolveDiscordChannelInfo,
+  resolveDiscordEmbedText,
+  resolveDiscordForwardedMessagesTextFromSnapshots,
+  resolveDiscordMessageChannelId,
+  type DiscordChannelInfo,
+  type DiscordChannelInfoClient,
+} from "./message-utils.js";
+import { getCachedThreadStarter, setCachedThreadStarter } from "./threading.cache.js";
+import type {
+  DiscordMessageEvent,
+  DiscordReplyDeliveryPlan,
+  DiscordThreadChannel,
+  DiscordThreadParentInfo,
+  DiscordThreadStarter,
+  DiscordThreadStarterRestAuthor,
+  DiscordThreadStarterRestMember,
+  DiscordThreadStarterRestMessage,
+} from "./threading.types.js";
+
+function isDiscordThreadType(type: ChannelType | undefined): boolean {
+  return (
+    type === ChannelType.PublicThread ||
+    type === ChannelType.PrivateThread ||
+    type === ChannelType.AnnouncementThread
+  );
+}
+
+function isDiscordForumParentType(parentType: ChannelType | undefined): boolean {
+  return parentType === ChannelType.GuildForum || parentType === ChannelType.GuildMedia;
+}
+
+export function resolveDiscordThreadChannel(params: {
+  isGuildMessage: boolean;
+  message: DiscordMessageEvent["message"];
+  channelInfo: DiscordChannelInfo | null;
+  messageChannelId?: string;
+}): DiscordThreadChannel | null {
+  if (!params.isGuildMessage) {
+    return null;
+  }
+  const { message, channelInfo } = params;
+  const channel = "channel" in message ? (message as { channel?: unknown }).channel : undefined;
+  const isThreadChannel =
+    channel &&
+    typeof channel === "object" &&
+    "isThread" in channel &&
+    typeof (channel as { isThread?: unknown }).isThread === "function" &&
+    (channel as { isThread: () => boolean }).isThread();
+  if (isThreadChannel) {
+    return channel as unknown as DiscordThreadChannel;
+  }
+  if (!isDiscordThreadType(channelInfo?.type)) {
+    return null;
+  }
+  const messageChannelId =
+    params.messageChannelId ||
+    resolveDiscordMessageChannelId({
+      message,
+    });
+  if (!messageChannelId) {
+    return null;
+  }
+  return {
+    id: messageChannelId,
+    name: channelInfo?.name ?? undefined,
+    parentId: channelInfo?.parentId ?? undefined,
+    parent: undefined,
+    ownerId: channelInfo?.ownerId ?? undefined,
+  };
+}
+
+export async function resolveDiscordThreadParentInfo(params: {
+  client: DiscordChannelInfoClient;
+  threadChannel: DiscordThreadChannel;
+  channelInfo: DiscordChannelInfo | null;
+}): Promise<DiscordThreadParentInfo> {
+  const { threadChannel, channelInfo, client } = params;
+  const parent = resolveDiscordChannelParentSafe(threadChannel);
+  let parentId =
+    resolveDiscordChannelParentIdSafe(threadChannel) ??
+    resolveDiscordChannelIdSafe(parent) ??
+    channelInfo?.parentId ??
+    undefined;
+  if (!parentId && threadChannel.id) {
+    const threadInfo = await resolveDiscordChannelInfo(client, threadChannel.id);
+    parentId = threadInfo?.parentId ?? undefined;
+  }
+  if (!parentId) {
+    return {};
+  }
+  let parentName = resolveDiscordChannelNameSafe(parent);
+  const parentInfo = await resolveDiscordChannelInfo(client, parentId);
+  parentName = parentName ?? parentInfo?.name;
+  const parentType = parentInfo?.type;
+  return { id: parentId, name: parentName, type: parentType };
+}
+
+export async function resolveDiscordThreadStarter(params: {
+  channel: DiscordThreadChannel;
+  client: Client;
+  parentId?: string;
+  parentType?: ChannelType;
+  resolveTimestampMs: (value?: string | null) => number | undefined;
+}): Promise<DiscordThreadStarter | null> {
+  const cacheKey = params.channel.id;
+  const now = Date.now();
+  const cached = getCachedThreadStarter(cacheKey, now);
+  if (cached) {
+    return cached;
+  }
+  try {
+    const messageChannelId = resolveDiscordThreadStarterMessageChannelId(params);
+    if (!messageChannelId) {
+      return null;
+    }
+    const starter = await fetchDiscordThreadStarterMessage({
+      client: params.client,
+      messageChannelId,
+      threadId: params.channel.id,
+    });
+    if (!starter) {
+      return null;
+    }
+    const payload = buildDiscordThreadStarterPayload({
+      starter,
+      resolveTimestampMs: params.resolveTimestampMs,
+    });
+    if (!payload) {
+      return null;
+    }
+    setCachedThreadStarter(cacheKey, payload, Date.now());
+    return payload;
+  } catch {
+    return null;
+  }
+}
+
+function resolveDiscordThreadStarterMessageChannelId(params: {
+  channel: DiscordThreadChannel;
+  parentId?: string;
+  parentType?: ChannelType;
+}): string | undefined {
+  return isDiscordForumParentType(params.parentType) ? params.channel.id : params.parentId;
+}
+
+async function fetchDiscordThreadStarterMessage(params: {
+  client: Client;
+  messageChannelId: string;
+  threadId: string;
+}): Promise<DiscordThreadStarterRestMessage | null> {
+  const starter = await getChannelMessage(
+    params.client.rest,
+    params.messageChannelId,
+    params.threadId,
+  );
+  return starter ? (starter as DiscordThreadStarterRestMessage) : null;
+}
+
+function buildDiscordThreadStarterPayload(params: {
+  starter: DiscordThreadStarterRestMessage;
+  resolveTimestampMs: (value?: string | null) => number | undefined;
+}): DiscordThreadStarter | null {
+  const text = resolveDiscordThreadStarterText(params.starter);
+  if (!text) {
+    return null;
+  }
+  return {
+    text,
+    ...resolveDiscordThreadStarterIdentity(params.starter),
+    timestamp: params.resolveTimestampMs(params.starter.timestamp) ?? undefined,
+  };
+}
+
+function resolveDiscordThreadStarterText(starter: DiscordThreadStarterRestMessage): string {
+  const content = normalizeOptionalString(starter.content) ?? "";
+  const embedText = resolveDiscordEmbedText(starter.embeds?.[0]);
+  const forwardedText = resolveDiscordForwardedMessagesTextFromSnapshots(starter.message_snapshots);
+  return content || embedText || forwardedText;
+}
+
+function resolveDiscordThreadStarterIdentity(
+  starter: DiscordThreadStarterRestMessage,
+): Omit<DiscordThreadStarter, "text" | "timestamp"> {
+  const author = resolveDiscordThreadStarterAuthor(starter);
+  return {
+    author,
+    authorId: starter.author?.id ?? undefined,
+    authorName: starter.author?.username ?? undefined,
+    authorTag: resolveDiscordThreadStarterAuthorTag(starter.author),
+    memberRoleIds: resolveDiscordThreadStarterRoleIds(starter.member),
+  };
+}
+
+function resolveDiscordThreadStarterAuthor(starter: DiscordThreadStarterRestMessage): string {
+  return (
+    starter.member?.nick ??
+    starter.member?.displayName ??
+    resolveDiscordThreadStarterAuthorTag(starter.author) ??
+    starter.author?.username ??
+    starter.author?.id ??
+    "Unknown"
+  );
+}
+
+function resolveDiscordThreadStarterAuthorTag(
+  author: DiscordThreadStarterRestAuthor | null | undefined,
+): string | undefined {
+  if (!author?.username || !author.discriminator) {
+    return undefined;
+  }
+  if (author.discriminator !== "0") {
+    return `${author.username}#${author.discriminator}`;
+  }
+  return author.username;
+}
+
+function resolveDiscordThreadStarterRoleIds(
+  member: DiscordThreadStarterRestMember | null | undefined,
+): string[] | undefined {
+  return Array.isArray(member?.roles) ? member.roles : undefined;
+}
+
+export function resolveDiscordReplyTarget(opts: {
+  replyToMode: ReplyToMode;
+  replyToId?: string;
+  hasReplied: boolean;
+}): string | undefined {
+  if (opts.replyToMode === "off") {
+    return undefined;
+  }
+  const replyToId = normalizeOptionalString(opts.replyToId);
+  if (!replyToId) {
+    return undefined;
+  }
+  if (opts.replyToMode === "all") {
+    return replyToId;
+  }
+  return opts.hasReplied ? undefined : replyToId;
+}
+
+export function sanitizeDiscordThreadName(rawName: string, fallbackId: string): string {
+  const cleanedName = rawName
+    .replace(/<@!?\d+>/g, "")
+    .replace(/<@&\d+>/g, "")
+    .replace(/<#\d+>/g, "")
+    .replace(/\s+/g, " ")
+    .trim();
+  const baseSource = cleanedName || `Thread ${fallbackId}`;
+  const base = truncateUtf16Safe(baseSource, 80);
+  return truncateUtf16Safe(base, 100) || `Thread ${fallbackId}`;
+}
+
+export function resolveDiscordReplyDeliveryPlan(params: {
+  replyTarget: string;
+  replyToMode: ReplyToMode;
+  messageId: string;
+  threadChannel?: DiscordThreadChannel | null;
+  createdThreadId?: string | null;
+}): DiscordReplyDeliveryPlan {
+  const originalReplyTarget = params.replyTarget;
+  let deliverTarget = originalReplyTarget;
+  let replyTarget = originalReplyTarget;
+
+  if (params.createdThreadId) {
+    deliverTarget = `channel:${params.createdThreadId}`;
+    replyTarget = deliverTarget;
+  }
+  const allowReference = deliverTarget === originalReplyTarget;
+  const replyReference = createReplyReferencePlanner({
+    replyToMode: allowReference ? params.replyToMode : "off",
+    existingId: params.threadChannel ? params.messageId : undefined,
+    startId: params.messageId,
+    allowReference,
+  });
+  return { deliverTarget, replyTarget, replyReference };
+}

package/src/monitor/threading.ts

@@ -0,0 +1,20 @@
+export {
+  maybeCreateDiscordAutoThread,
+  resolveDiscordAutoThreadContext,
+  resolveDiscordAutoThreadReplyPlan,
+} from "./threading.auto-thread.js";
+export { resetDiscordThreadStarterCacheForTest } from "./threading.cache.js";
+export {
+  resolveDiscordReplyDeliveryPlan,
+  resolveDiscordReplyTarget,
+  resolveDiscordThreadChannel,
+  resolveDiscordThreadParentInfo,
+  resolveDiscordThreadStarter,
+  sanitizeDiscordThreadName,
+} from "./threading.starter.js";
+export type {
+  DiscordAutoThreadContext,
+  DiscordAutoThreadReplyPlan,
+  DiscordThreadChannel,
+  DiscordThreadStarter,
+} from "./threading.types.js";

package/src/monitor/threading.types.ts

@@ -0,0 +1,102 @@
+import type { APIAttachment, APIStickerItem } from "discord-api-types/v10";
+import type { AutoBotConfig } from "autobot/plugin-sdk/config-contracts";
+import type { createReplyReferencePlanner } from "autobot/plugin-sdk/reply-reference";
+import type { ChannelType, Client, MessageCreateListener } from "../internal/discord.js";
+import type { DiscordChannelConfigResolved } from "./allow-list.js";
+
+export type DiscordThreadChannel = {
+  id: string;
+  name?: string | null;
+  parentId?: string | null;
+  parent?: { id?: string; name?: string };
+  ownerId?: string | null;
+};
+
+export type DiscordThreadStarter = {
+  text: string;
+  author: string;
+  authorId?: string;
+  authorName?: string;
+  authorTag?: string;
+  memberRoleIds?: string[];
+  timestamp?: number;
+};
+
+export type DiscordThreadParentInfo = {
+  id?: string;
+  name?: string;
+  type?: ChannelType;
+};
+
+type DiscordThreadStarterRestEmbed = {
+  title?: string | null;
+  description?: string | null;
+};
+
+type DiscordThreadStarterRestSnapshotMessage = {
+  content?: string | null;
+  attachments?: APIAttachment[] | null;
+  embeds?: DiscordThreadStarterRestEmbed[] | null;
+  sticker_items?: APIStickerItem[] | null;
+};
+
+export type DiscordThreadStarterRestAuthor = {
+  id?: string | null;
+  username?: string | null;
+  discriminator?: string | null;
+};
+
+export type DiscordThreadStarterRestMember = {
+  nick?: string | null;
+  displayName?: string | null;
+  roles?: string[];
+};
+
+export type DiscordThreadStarterRestMessage = {
+  content?: string | null;
+  embeds?: DiscordThreadStarterRestEmbed[] | null;
+  message_snapshots?: Array<{ message?: DiscordThreadStarterRestSnapshotMessage | null }> | null;
+  member?: DiscordThreadStarterRestMember | null;
+  author?: DiscordThreadStarterRestAuthor | null;
+  timestamp?: string | null;
+};
+
+export type DiscordMessageEvent = Parameters<MessageCreateListener["handle"]>[0];
+
+export type DiscordReplyDeliveryPlan = {
+  deliverTarget: string;
+  replyTarget: string;
+  replyReference: ReturnType<typeof createReplyReferencePlanner>;
+};
+
+export type DiscordAutoThreadContext = {
+  createdThreadId: string;
+  From: string;
+  To: string;
+  OriginatingTo: string;
+  SessionKey: string;
+  ModelParentSessionKey?: string;
+  ParentSessionKey?: string;
+};
+
+export type DiscordAutoThreadReplyPlan = DiscordReplyDeliveryPlan & {
+  createdThreadId?: string;
+  autoThreadContext: DiscordAutoThreadContext | null;
+};
+
+export type MaybeCreateDiscordAutoThreadParams = {
+  client: Client;
+  message: DiscordMessageEvent["message"];
+  messageChannelId?: string;
+  channel?: string;
+  isGuildMessage: boolean;
+  channelConfig?: DiscordChannelConfigResolved | null;
+  threadChannel?: DiscordThreadChannel | null;
+  channelType?: ChannelType;
+  channelName?: string;
+  channelDescription?: string;
+  baseText: string;
+  combinedBody: string;
+  cfg: AutoBotConfig;
+  agentId?: string;
+};

package/src/monitor/timeouts.ts

@@ -0,0 +1,84 @@
+// Compatibility constants for existing imports. Discord no longer enforces
+// channel-owned listener or inbound run timeouts.
+export const DISCORD_DEFAULT_LISTENER_TIMEOUT_MS = 120_000;
+export const DISCORD_DEFAULT_INBOUND_WORKER_TIMEOUT_MS = 30 * 60_000;
+
+export const DISCORD_ATTACHMENT_IDLE_TIMEOUT_MS = 60_000;
+export const DISCORD_ATTACHMENT_TOTAL_TIMEOUT_MS = 120_000;
+
+export function mergeAbortSignals(
+  signals: Array<AbortSignal | undefined>,
+): AbortSignal | undefined {
+  const activeSignals = signals.filter((signal): signal is AbortSignal => Boolean(signal));
+  if (activeSignals.length === 0) {
+    return undefined;
+  }
+  if (activeSignals.length === 1) {
+    return activeSignals[0];
+  }
+  if (typeof AbortSignal.any === "function") {
+    return AbortSignal.any(activeSignals);
+  }
+  const fallbackController = new AbortController();
+  for (const signal of activeSignals) {
+    if (signal.aborted) {
+      fallbackController.abort();
+      return fallbackController.signal;
+    }
+  }
+  const abortFallback = () => {
+    fallbackController.abort();
+    for (const signal of activeSignals) {
+      signal.removeEventListener("abort", abortFallback);
+    }
+  };
+  for (const signal of activeSignals) {
+    signal.addEventListener("abort", abortFallback, { once: true });
+  }
+  return fallbackController.signal;
+}
+
+export async function raceWithTimeout<T, U>(params: {
+  promise: Promise<T>;
+  timeoutMs: number;
+  onTimeout: () => U;
+}): Promise<T | U> {
+  let timeoutTimer: ReturnType<typeof setTimeout> | undefined;
+  const timeoutPromise = new Promise<U>((resolve) => {
+    timeoutTimer = setTimeout(() => resolve(params.onTimeout()), Math.max(1, params.timeoutMs));
+    timeoutTimer.unref?.();
+  });
+  try {
+    return await Promise.race([params.promise, timeoutPromise]);
+  } finally {
+    if (timeoutTimer) {
+      clearTimeout(timeoutTimer);
+    }
+  }
+}
+
+export async function withAbortTimeout<T>(params: {
+  timeoutMs: number;
+  createTimeoutError: () => Error;
+  run: (signal: AbortSignal) => Promise<T>;
+}): Promise<T> {
+  const controller = new AbortController();
+  let timeoutTimer: ReturnType<typeof setTimeout> | undefined;
+  const timeoutPromise = new Promise<never>((_, reject) => {
+    timeoutTimer = setTimeout(
+      () => {
+        controller.abort();
+        reject(params.createTimeoutError());
+      },
+      Math.max(1, params.timeoutMs),
+    );
+    timeoutTimer.unref?.();
+  });
+  try {
+    return await Promise.race([params.run(controller.signal), timeoutPromise]);
+  } finally {
+    if (timeoutTimer) {
+      clearTimeout(timeoutTimer);
+    }
+  }
+}

package/src/monitor/typing.ts

@@ -0,0 +1,17 @@
+import { sendChannelTyping, type RequestClient } from "../internal/discord.js";
+import { raceWithTimeout } from "./timeouts.js";
+
+const DISCORD_TYPING_START_TIMEOUT_MS = 5_000;
+
+export async function sendTyping(params: { rest: RequestClient; channelId: string }) {
+  const result = await raceWithTimeout({
+    promise: sendChannelTyping(params.rest, params.channelId).then(() => ({
+      kind: "sent" as const,
+    })),
+    timeoutMs: DISCORD_TYPING_START_TIMEOUT_MS,
+    onTimeout: () => ({ kind: "timeout" as const }),
+  });
+  if (result.kind === "timeout") {
+    throw new Error(`discord typing start timed out after ${DISCORD_TYPING_START_TIMEOUT_MS}ms`);
+  }
+}

package/src/monitor.gateway.ts

@@ -0,0 +1,75 @@
+import type { DiscordGatewayHandle } from "./monitor/gateway-handle.js";
+import {
+  DiscordGatewayEvent,
+  DiscordGatewayLifecycleError,
+  DiscordGatewaySupervisor,
+} from "./monitor/gateway-supervisor.js";
+
+export { getDiscordGatewayEmitter } from "./monitor/gateway-supervisor.js";
+
+export type WaitForDiscordGatewayStopParams = {
+  gateway?: DiscordGatewayHandle;
+  abortSignal?: AbortSignal;
+  gatewaySupervisor?: Pick<DiscordGatewaySupervisor, "attachLifecycle" | "detachLifecycle">;
+  onGatewayEvent?: (event: DiscordGatewayEvent) => "continue" | "stop";
+  registerForceStop?: (forceStop: (err: unknown) => void) => void;
+};
+
+export async function waitForDiscordGatewayStop(
+  params: WaitForDiscordGatewayStopParams,
+): Promise<void> {
+  const { gateway, abortSignal } = params;
+  return await new Promise<void>((resolve, reject) => {
+    let settled = false;
+    const cleanup = () => {
+      abortSignal?.removeEventListener("abort", onAbort);
+      params.gatewaySupervisor?.detachLifecycle();
+    };
+    const finishResolve = () => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      try {
+        gateway?.disconnect?.();
+      } finally {
+        // remove listeners after disconnect so late "error" events emitted
+        // during disconnect are still handled instead of becoming uncaught
+        cleanup();
+        resolve();
+      }
+    };
+    const finishReject = (err: unknown) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      try {
+        gateway?.disconnect?.();
+      } finally {
+        cleanup();
+        reject(err);
+      }
+    };
+    const onAbort = () => {
+      finishResolve();
+    };
+    const onGatewayEvent = (event: DiscordGatewayEvent) => {
+      const shouldStop = (params.onGatewayEvent?.(event) ?? "stop") === "stop";
+      if (shouldStop) {
+        finishReject(new DiscordGatewayLifecycleError(event));
+      }
+    };
+    const onForceStop = (err: unknown) => {
+      finishReject(err);
+    };
+    if (abortSignal?.aborted) {
+      onAbort();
+      return;
+    }
+
+    abortSignal?.addEventListener("abort", onAbort, { once: true });
+    params.gatewaySupervisor?.attachLifecycle(onGatewayEvent);
+    params.registerForceStop?.(onForceStop);
+  });
+}

package/src/monitor.ts

@@ -0,0 +1,28 @@
+export type {
+  DiscordAllowList,
+  DiscordChannelConfigResolved,
+  DiscordGuildEntryResolved,
+} from "./monitor/allow-list.js";
+export {
+  allowListMatches,
+  isDiscordGroupAllowedByPolicy,
+  normalizeDiscordAllowList,
+  normalizeDiscordSlug,
+  resolveDiscordChannelConfig,
+  resolveDiscordChannelConfigWithFallback,
+  resolveDiscordCommandAuthorized,
+  resolveDiscordGuildEntry,
+  resolveDiscordShouldRequireMention,
+  resolveGroupDmAllow,
+  shouldEmitDiscordReactionNotification,
+} from "./monitor/allow-list.js";
+export type { DiscordMessageEvent, DiscordMessageHandler } from "./monitor/listeners.js";
+export { registerDiscordListener } from "./monitor/listeners.js";
+
+export { createDiscordMessageHandler } from "./monitor/message-handler.js";
+export { buildDiscordMediaPayload } from "./monitor/message-utils.js";
+export { createDiscordNativeCommand } from "./monitor/native-command.js";
+export type { MonitorDiscordOpts } from "./monitor/provider.js";
+export { monitorDiscordProvider } from "./monitor/provider.js";
+
+export { resolveDiscordReplyTarget, sanitizeDiscordThreadName } from "./monitor/threading.js";

package/src/network-config.ts

@@ -0,0 +1,79 @@
+import * as dns from "node:dns";
+import type { LookupFunction } from "node:net";
+
+const DISCORD_DNS_HOSTS = ["discord.com", "discord.gg", "gateway.discord.gg"];
+
+function normalizeHostname(hostname: string): string {
+  return hostname.trim().toLowerCase();
+}
+
+function isDiscordTransportHostname(hostname: string): boolean {
+  const normalized = normalizeHostname(hostname);
+  if (!normalized) {
+    return false;
+  }
+  return DISCORD_DNS_HOSTS.some(
+    (target) => normalized === target || normalized.endsWith(`.${target}`),
+  );
+}
+
+function reorderLookupAddresses(addresses: dns.LookupAddress[]): dns.LookupAddress[] {
+  if (!Array.isArray(addresses) || addresses.length < 2) {
+    return addresses;
+  }
+  const ipv4 = addresses.filter((entry) => entry.family === 4);
+  const ipv6 = addresses.filter((entry) => entry.family === 6);
+  if (ipv4.length === 0) {
+    return ipv6;
+  }
+  if (ipv6.length === 0) {
+    return ipv4;
+  }
+  return [...ipv4, ...ipv6];
+}
+
+export function createDiscordDnsLookup(): LookupFunction {
+  return (hostname, options, callback) => {
+    if (!isDiscordTransportHostname(hostname)) {
+      return dns.lookup(hostname, options, callback);
+    }
+
+    const lookupOptions: dns.LookupOptions =
+      typeof options === "number"
+        ? { family: options }
+        : options === undefined
+          ? {}
+          : ({ ...options } as dns.LookupOptions);
+
+    if (lookupOptions.family === 4 || lookupOptions.family === 6) {
+      return dns.lookup(hostname, lookupOptions, callback as never);
+    }
+
+    dns.lookup(hostname, { ...lookupOptions, all: true }, (err, addresses) => {
+      if (err) {
+        callback(err, "", 4);
+        return;
+      }
+      if (!Array.isArray(addresses)) {
+        callback(new Error("Expected all lookup addresses to be an array"), "", 4);
+        return;
+      }
+
+      const reordered = reorderLookupAddresses(addresses);
+      if (lookupOptions.all === true) {
+        (callback as (err: NodeJS.ErrnoException | null, addresses: dns.LookupAddress[]) => void)(
+          null,
+          reordered,
+        );
+        return;
+      }
+
+      const first = reordered[0];
+      if (!first) {
+        callback(new Error("No Discord DNS addresses resolved"), "", 4);
+        return;
+      }
+      callback(null, first.address, first.family);
+    });
+  };
+}