@gakr-gakr/discord 0.1.0

package/src/outbound-payload.ts

@@ -0,0 +1,208 @@
+import {
+  attachChannelToResult,
+  type ChannelOutboundAdapter,
+} from "autobot/plugin-sdk/channel-send-result";
+import {
+  resolvePayloadMediaUrls,
+  sendPayloadMediaSequenceOrFallback,
+  sendTextMediaPayload,
+} from "autobot/plugin-sdk/reply-payload";
+import { normalizeOptionalString } from "autobot/plugin-sdk/string-coerce-runtime";
+import { normalizeDiscordApprovalPayload } from "./outbound-approval.js";
+import {
+  resolveDiscordComponentSpec,
+  sendDiscordComponentMessageLazy,
+} from "./outbound-components.js";
+import { createDiscordPayloadSendContext } from "./outbound-send-context.js";
+import { createDiscordSendReceipt } from "./send.receipt.js";
+import type { DiscordSendComponents, DiscordSendEmbeds } from "./send.shared.js";
+
+export async function sendDiscordOutboundPayload(params: {
+  ctx: Parameters<NonNullable<ChannelOutboundAdapter["sendPayload"]>>[0];
+  fallbackAdapter: ChannelOutboundAdapter;
+}): Promise<Awaited<ReturnType<NonNullable<ChannelOutboundAdapter["sendPayload"]>>>> {
+  const ctx = params.ctx;
+  const payload = normalizeDiscordApprovalPayload({
+    ...ctx.payload,
+    text: ctx.payload.text ?? "",
+  });
+  const mediaUrls = resolvePayloadMediaUrls(payload);
+  const sendContext = await createDiscordPayloadSendContext(ctx);
+
+  if (payload.audioAsVoice && mediaUrls.length > 0) {
+    let lastResult = await sendContext.withRetry(
+      async () =>
+        await sendContext.sendVoice(sendContext.target, mediaUrls[0], {
+          cfg: ctx.cfg,
+          replyTo: sendContext.resolveReplyTo(),
+          accountId: ctx.accountId ?? undefined,
+          silent: ctx.silent ?? undefined,
+        }),
+    );
+    if (payload.text?.trim()) {
+      lastResult = await sendContext.withRetry(
+        async () =>
+          await sendContext.send(sendContext.target, payload.text, {
+            verbose: false,
+            replyTo: sendContext.resolveReplyTo(),
+            accountId: ctx.accountId ?? undefined,
+            silent: ctx.silent ?? undefined,
+            cfg: ctx.cfg,
+            ...sendContext.formatting,
+          }),
+      );
+    }
+    for (const mediaUrl of mediaUrls.slice(1)) {
+      lastResult = await sendContext.withRetry(
+        async () =>
+          await sendContext.send(sendContext.target, "", {
+            verbose: false,
+            mediaUrl,
+            mediaAccess: ctx.mediaAccess,
+            mediaLocalRoots: ctx.mediaLocalRoots,
+            mediaReadFile: ctx.mediaReadFile,
+            replyTo: sendContext.resolveReplyTo(),
+            accountId: ctx.accountId ?? undefined,
+            silent: ctx.silent ?? undefined,
+            cfg: ctx.cfg,
+            ...sendContext.formatting,
+          }),
+      );
+    }
+    return attachChannelToResult("discord", lastResult);
+  }
+
+  const componentSpec = await resolveDiscordComponentSpec(payload);
+  if (!componentSpec) {
+    const discordData =
+      payload.channelData?.discord &&
+      typeof payload.channelData.discord === "object" &&
+      !Array.isArray(payload.channelData.discord)
+        ? (payload.channelData.discord as Record<string, unknown>)
+        : {};
+    const nativeComponents = Array.isArray(discordData.components)
+      ? (discordData.components as DiscordSendComponents)
+      : undefined;
+    const embeds = Array.isArray(discordData.embeds)
+      ? (discordData.embeds as DiscordSendEmbeds)
+      : undefined;
+    const filename = normalizeOptionalString(discordData.filename);
+    if (nativeComponents || embeds?.length || filename) {
+      const result = await sendPayloadMediaSequenceOrFallback({
+        text: payload.text ?? "",
+        mediaUrls,
+        fallbackResult: {
+          messageId: "",
+          channelId: sendContext.target,
+          receipt: createDiscordSendReceipt({
+            platformMessageIds: [],
+            channelId: sendContext.target,
+            kind: "unknown",
+          }),
+        },
+        sendNoMedia: async () =>
+          await sendContext.withRetry(
+            async () =>
+              await sendContext.send(sendContext.target, payload.text ?? "", {
+                verbose: false,
+                components: nativeComponents,
+                embeds,
+                filename,
+                replyTo: sendContext.resolveReplyTo(),
+                accountId: ctx.accountId ?? undefined,
+                silent: ctx.silent ?? undefined,
+                cfg: ctx.cfg,
+                ...sendContext.formatting,
+              }),
+          ),
+        send: async ({ text, mediaUrl, isFirst }) =>
+          await sendContext.withRetry(
+            async () =>
+              await sendContext.send(sendContext.target, text, {
+                verbose: false,
+                mediaUrl,
+                mediaAccess: ctx.mediaAccess,
+                mediaLocalRoots: ctx.mediaLocalRoots,
+                mediaReadFile: ctx.mediaReadFile,
+                components: isFirst ? nativeComponents : undefined,
+                embeds: isFirst ? embeds : undefined,
+                filename: isFirst ? filename : undefined,
+                replyTo: sendContext.resolveReplyTo(),
+                accountId: ctx.accountId ?? undefined,
+                silent: ctx.silent ?? undefined,
+                cfg: ctx.cfg,
+                ...sendContext.formatting,
+              }),
+          ),
+      });
+      return attachChannelToResult("discord", result);
+    }
+    return await sendTextMediaPayload({
+      channel: "discord",
+      ctx: {
+        ...ctx,
+        payload,
+      },
+      adapter: params.fallbackAdapter,
+    });
+  }
+
+  const result = await sendPayloadMediaSequenceOrFallback({
+    text: payload.text ?? "",
+    mediaUrls,
+    fallbackResult: {
+      messageId: "",
+      channelId: sendContext.target,
+      receipt: createDiscordSendReceipt({
+        platformMessageIds: [],
+        channelId: sendContext.target,
+        kind: "unknown",
+      }),
+    },
+    sendNoMedia: async () =>
+      await sendContext.withRetry(
+        async () =>
+          await sendDiscordComponentMessageLazy(sendContext.target, componentSpec, {
+            replyTo: sendContext.resolveReplyTo(),
+            accountId: ctx.accountId ?? undefined,
+            silent: ctx.silent ?? undefined,
+            cfg: ctx.cfg,
+            ...sendContext.formatting,
+          }),
+      ),
+    send: async ({ text, mediaUrl, isFirst }) => {
+      if (isFirst) {
+        return await sendContext.withRetry(
+          async () =>
+            await sendDiscordComponentMessageLazy(sendContext.target, componentSpec, {
+              mediaUrl,
+              mediaAccess: ctx.mediaAccess,
+              mediaLocalRoots: ctx.mediaLocalRoots,
+              mediaReadFile: ctx.mediaReadFile,
+              replyTo: sendContext.resolveReplyTo(),
+              accountId: ctx.accountId ?? undefined,
+              silent: ctx.silent ?? undefined,
+              cfg: ctx.cfg,
+              ...sendContext.formatting,
+            }),
+        );
+      }
+      return await sendContext.withRetry(
+        async () =>
+          await sendContext.send(sendContext.target, text, {
+            verbose: false,
+            mediaUrl,
+            mediaAccess: ctx.mediaAccess,
+            mediaLocalRoots: ctx.mediaLocalRoots,
+            mediaReadFile: ctx.mediaReadFile,
+            replyTo: sendContext.resolveReplyTo(),
+            accountId: ctx.accountId ?? undefined,
+            silent: ctx.silent ?? undefined,
+            cfg: ctx.cfg,
+            ...sendContext.formatting,
+          }),
+      );
+    },
+  });
+  return attachChannelToResult("discord", result);
+}

package/src/outbound-send-context.ts

@@ -0,0 +1,92 @@
+import type { AutoBotConfig, ReplyToMode } from "autobot/plugin-sdk/config-contracts";
+import { createReplyToFanout, type ReplyToResolution } from "autobot/plugin-sdk/outbound-runtime";
+import {
+  resolveOutboundSendDep,
+  type OutboundSendDeps,
+} from "autobot/plugin-sdk/outbound-send-deps";
+import { normalizeOptionalStringifiedId } from "autobot/plugin-sdk/string-coerce-runtime";
+import { withDiscordDeliveryRetry } from "./delivery-retry.js";
+
+type DiscordSendRuntime = typeof import("./send.js");
+
+export type DiscordSendFn = DiscordSendRuntime["sendMessageDiscord"];
+export type DiscordVoiceSendFn = DiscordSendRuntime["sendVoiceMessageDiscord"];
+type DiscordFormattingOptions = {
+  textLimit?: number;
+  maxLinesPerMessage?: number;
+  tableMode?: NonNullable<Parameters<DiscordSendFn>[2]>["tableMode"];
+  chunkMode?: NonNullable<Parameters<DiscordSendFn>[2]>["chunkMode"];
+};
+
+let discordSendRuntimePromise: Promise<DiscordSendRuntime> | undefined;
+
+export async function loadDiscordSendRuntime(): Promise<DiscordSendRuntime> {
+  discordSendRuntimePromise ??= import("./send.js");
+  return await discordSendRuntimePromise;
+}
+
+export function resolveDiscordOutboundTarget(params: {
+  to: string;
+  threadId?: string | number | null;
+}): string {
+  if (params.threadId == null) {
+    return params.to;
+  }
+  const threadId = normalizeOptionalStringifiedId(params.threadId) ?? "";
+  if (!threadId) {
+    return params.to;
+  }
+  return `channel:${threadId}`;
+}
+
+export function resolveDiscordFormattingOptions(ctx: {
+  formatting?: DiscordFormattingOptions;
+}): DiscordFormattingOptions {
+  const formatting = ctx.formatting;
+  return {
+    textLimit: formatting?.textLimit,
+    maxLinesPerMessage: formatting?.maxLinesPerMessage,
+    tableMode: formatting?.tableMode,
+    chunkMode: formatting?.chunkMode,
+  };
+}
+
+export async function createDiscordPayloadSendContext(ctx: {
+  cfg: AutoBotConfig;
+  to: string;
+  accountId?: string | null;
+  deps?: OutboundSendDeps;
+  replyToId?: string | null;
+  replyToIdSource?: ReplyToResolution["source"];
+  replyToMode?: ReplyToMode;
+  formatting?: DiscordFormattingOptions;
+  threadId?: string | number | null;
+}): Promise<{
+  target: string;
+  formatting: DiscordFormattingOptions;
+  resolveReplyTo: () => string | undefined;
+  send: DiscordSendFn;
+  sendVoice: DiscordVoiceSendFn;
+  withRetry: <T>(fn: () => Promise<T>) => Promise<T>;
+}> {
+  const runtime = await loadDiscordSendRuntime();
+  return {
+    target: resolveDiscordOutboundTarget({ to: ctx.to, threadId: ctx.threadId }),
+    formatting: resolveDiscordFormattingOptions(ctx),
+    resolveReplyTo: createReplyToFanout({
+      replyToId: ctx.replyToId,
+      replyToIdSource: ctx.replyToIdSource,
+      replyToMode: ctx.replyToMode,
+    }),
+    send: resolveOutboundSendDep<DiscordSendFn>(ctx.deps, "discord") ?? runtime.sendMessageDiscord,
+    sendVoice:
+      resolveOutboundSendDep<DiscordVoiceSendFn>(ctx.deps, "discordVoice") ??
+      runtime.sendVoiceMessageDiscord,
+    withRetry: async (fn) =>
+      await withDiscordDeliveryRetry({
+        cfg: ctx.cfg,
+        accountId: ctx.accountId,
+        fn,
+      }),
+  };
+}

package/src/outbound-session-route.ts

@@ -0,0 +1,72 @@
+import { buildThreadAwareOutboundSessionRoute } from "autobot/plugin-sdk/channel-core";
+import type { AutoBotConfig } from "autobot/plugin-sdk/config-contracts";
+import { buildOutboundBaseSessionKey, type RoutePeer } from "autobot/plugin-sdk/routing";
+import { parseDiscordTarget } from "./target-parsing.js";
+
+export type ResolveDiscordOutboundSessionRouteParams = {
+  cfg: AutoBotConfig;
+  agentId: string;
+  accountId?: string | null;
+  target: string;
+  resolvedTarget?: { kind: string };
+  replyToId?: string | null;
+  threadId?: string | number | null;
+};
+
+export function resolveDiscordOutboundSessionRoute(
+  params: ResolveDiscordOutboundSessionRouteParams,
+) {
+  const parsed = parseDiscordTarget(params.target, {
+    defaultKind: resolveDiscordOutboundTargetKindHint(params),
+  });
+  if (!parsed) {
+    return null;
+  }
+  const isDm = parsed.kind === "user";
+  const peer: RoutePeer = {
+    kind: isDm ? "direct" : "channel",
+    id: parsed.id,
+  };
+  const baseSessionKey = buildOutboundBaseSessionKey({
+    cfg: params.cfg,
+    agentId: params.agentId,
+    channel: "discord",
+    accountId: params.accountId,
+    peer,
+  });
+  return buildThreadAwareOutboundSessionRoute({
+    route: {
+      sessionKey: baseSessionKey,
+      baseSessionKey,
+      peer,
+      chatType: isDm ? ("direct" as const) : ("channel" as const),
+      from: isDm ? `discord:${parsed.id}` : `discord:channel:${parsed.id}`,
+      to: isDm ? `user:${parsed.id}` : `channel:${parsed.id}`,
+    },
+    threadId: params.threadId,
+    precedence: ["threadId"],
+    useSuffix: false,
+  });
+}
+
+function resolveDiscordOutboundTargetKindHint(params: {
+  target: string;
+  resolvedTarget?: { kind: string };
+}): "user" | "channel" | undefined {
+  const resolvedKind = params.resolvedTarget?.kind;
+  if (resolvedKind === "user") {
+    return "user";
+  }
+  if (resolvedKind === "group" || resolvedKind === "channel") {
+    return "channel";
+  }
+
+  const target = params.target.trim();
+  if (/^channel:/i.test(target)) {
+    return "channel";
+  }
+  if (/^(user:|discord:|@|<@!?)/i.test(target)) {
+    return "user";
+  }
+  return undefined;
+}

package/src/pluralkit.ts

@@ -0,0 +1,58 @@
+import { resolveFetch } from "autobot/plugin-sdk/fetch-runtime";
+
+const PLURALKIT_API_BASE = "https://api.pluralkit.me/v2";
+
+export type DiscordPluralKitConfig = {
+  enabled?: boolean;
+  token?: string;
+};
+
+export type PluralKitSystemInfo = {
+  id: string;
+  name?: string | null;
+  tag?: string | null;
+};
+
+export type PluralKitMemberInfo = {
+  id: string;
+  name?: string | null;
+  display_name?: string | null;
+};
+
+export type PluralKitMessageInfo = {
+  id: string;
+  original?: string | null;
+  sender?: string | null;
+  system?: PluralKitSystemInfo | null;
+  member?: PluralKitMemberInfo | null;
+};
+
+export async function fetchPluralKitMessageInfo(params: {
+  messageId: string;
+  config?: DiscordPluralKitConfig;
+  fetcher?: typeof fetch;
+}): Promise<PluralKitMessageInfo | null> {
+  if (!params.config?.enabled) {
+    return null;
+  }
+  const fetchImpl = resolveFetch(params.fetcher);
+  if (!fetchImpl) {
+    return null;
+  }
+  const headers: Record<string, string> = {};
+  if (params.config.token?.trim()) {
+    headers.Authorization = params.config.token.trim();
+  }
+  const res = await fetchImpl(`${PLURALKIT_API_BASE}/messages/${params.messageId}`, {
+    headers,
+  });
+  if (res.status === 404) {
+    return null;
+  }
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    const detail = text.trim() ? `: ${text.trim()}` : "";
+    throw new Error(`PluralKit API failed (${res.status})${detail}`);
+  }
+  return (await res.json()) as PluralKitMessageInfo;
+}

package/src/preview-streaming.ts

@@ -0,0 +1,18 @@
+import {
+  resolveChannelPreviewStreamMode,
+  type StreamingMode,
+} from "autobot/plugin-sdk/channel-streaming";
+
+type DiscordPreviewStreamMode = StreamingMode;
+
+export function resolveDiscordPreviewStreamMode(
+  params: {
+    streamMode?: unknown;
+    streaming?: unknown;
+  } = {},
+): DiscordPreviewStreamMode {
+  if (params.streaming === undefined && params.streamMode === undefined) {
+    return "progress";
+  }
+  return resolveChannelPreviewStreamMode(params, "off");
+}

package/src/probe.runtime.ts

@@ -0,0 +1 @@
+export * from "./probe.js";

package/src/probe.ts

@@ -0,0 +1,237 @@
+import type { BaseProbeResult } from "autobot/plugin-sdk/channel-contract";
+import { formatErrorMessage } from "autobot/plugin-sdk/error-runtime";
+import { resolveFetch } from "autobot/plugin-sdk/fetch-runtime";
+import { fetchWithTimeout } from "autobot/plugin-sdk/text-utility-runtime";
+import { DiscordApiError, fetchDiscord } from "./api.js";
+import { normalizeDiscordToken } from "./token.js";
+
+const DISCORD_API_BASE = "https://discord.com/api/v10";
+
+export type DiscordProbe = BaseProbeResult & {
+  status?: number | null;
+  elapsedMs: number;
+  bot?: { id?: string | null; username?: string | null };
+  application?: DiscordApplicationSummary;
+};
+
+export type DiscordPrivilegedIntentStatus = "enabled" | "limited" | "disabled";
+
+export type DiscordPrivilegedIntentsSummary = {
+  messageContent: DiscordPrivilegedIntentStatus;
+  guildMembers: DiscordPrivilegedIntentStatus;
+  presence: DiscordPrivilegedIntentStatus;
+};
+
+export type DiscordApplicationSummary = {
+  id?: string | null;
+  flags?: number | null;
+  intents?: DiscordPrivilegedIntentsSummary;
+};
+
+const DISCORD_APP_FLAG_GATEWAY_PRESENCE = 1 << 12;
+const DISCORD_APP_FLAG_GATEWAY_PRESENCE_LIMITED = 1 << 13;
+const DISCORD_APP_FLAG_GATEWAY_GUILD_MEMBERS = 1 << 14;
+const DISCORD_APP_FLAG_GATEWAY_GUILD_MEMBERS_LIMITED = 1 << 15;
+const DISCORD_APP_FLAG_GATEWAY_MESSAGE_CONTENT = 1 << 18;
+const DISCORD_APP_FLAG_GATEWAY_MESSAGE_CONTENT_LIMITED = 1 << 19;
+
+async function fetchDiscordApplicationMe(
+  token: string,
+  timeoutMs: number,
+  fetcher: typeof fetch,
+): Promise<{ id?: string; flags?: number } | undefined> {
+  try {
+    const normalized = normalizeDiscordToken(token, "channels.discord.token");
+    if (!normalized) {
+      return undefined;
+    }
+    return await fetchDiscord<{ id?: string; flags?: number }>(
+      "/oauth2/applications/@me",
+      normalized,
+      createDiscordTimeoutFetch(fetcher, timeoutMs),
+      { retry: { attempts: 1 } },
+    );
+  } catch {
+    return undefined;
+  }
+}
+
+function createDiscordTimeoutFetch(fetcher: typeof fetch, timeoutMs: number): typeof fetch {
+  const fetchImpl = getResolvedFetch(fetcher);
+  return ((input: RequestInfo | URL, init?: RequestInit) =>
+    fetchWithTimeout(
+      typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url,
+      init ?? {},
+      timeoutMs,
+      fetchImpl,
+    )) as typeof fetch;
+}
+
+export function resolveDiscordPrivilegedIntentsFromFlags(
+  flags: number,
+): DiscordPrivilegedIntentsSummary {
+  const resolve = (enabledBit: number, limitedBit: number) => {
+    if ((flags & enabledBit) !== 0) {
+      return "enabled";
+    }
+    if ((flags & limitedBit) !== 0) {
+      return "limited";
+    }
+    return "disabled";
+  };
+  return {
+    presence: resolve(DISCORD_APP_FLAG_GATEWAY_PRESENCE, DISCORD_APP_FLAG_GATEWAY_PRESENCE_LIMITED),
+    guildMembers: resolve(
+      DISCORD_APP_FLAG_GATEWAY_GUILD_MEMBERS,
+      DISCORD_APP_FLAG_GATEWAY_GUILD_MEMBERS_LIMITED,
+    ),
+    messageContent: resolve(
+      DISCORD_APP_FLAG_GATEWAY_MESSAGE_CONTENT,
+      DISCORD_APP_FLAG_GATEWAY_MESSAGE_CONTENT_LIMITED,
+    ),
+  };
+}
+
+export async function fetchDiscordApplicationSummary(
+  token: string,
+  timeoutMs: number,
+  fetcher: typeof fetch = fetch,
+): Promise<DiscordApplicationSummary | undefined> {
+  const json = await fetchDiscordApplicationMe(token, timeoutMs, fetcher);
+  if (!json) {
+    return undefined;
+  }
+  const flags =
+    typeof json.flags === "number" && Number.isFinite(json.flags) ? json.flags : undefined;
+  return {
+    id: json.id ?? null,
+    flags: flags ?? null,
+    intents:
+      typeof flags === "number" ? resolveDiscordPrivilegedIntentsFromFlags(flags) : undefined,
+  };
+}
+
+function getResolvedFetch(fetcher: typeof fetch): typeof fetch {
+  const fetchImpl = resolveFetch(fetcher);
+  if (!fetchImpl) {
+    throw new Error("fetch is not available");
+  }
+  return fetchImpl;
+}
+
+export async function probeDiscord(
+  token: string,
+  timeoutMs: number,
+  opts?: { fetcher?: typeof fetch; includeApplication?: boolean },
+): Promise<DiscordProbe> {
+  const started = Date.now();
+  const fetcher = opts?.fetcher ?? fetch;
+  const includeApplication = opts?.includeApplication === true;
+  const normalized = normalizeDiscordToken(token, "channels.discord.token");
+  const result: DiscordProbe = {
+    ok: false,
+    status: null,
+    error: null,
+    elapsedMs: 0,
+  };
+  if (!normalized) {
+    return {
+      ...result,
+      error: "missing token",
+      elapsedMs: Date.now() - started,
+    };
+  }
+  try {
+    const res = await fetchWithTimeout(
+      `${DISCORD_API_BASE}/users/@me`,
+      { headers: { Authorization: `Bot ${normalized}` } },
+      timeoutMs,
+      getResolvedFetch(fetcher),
+    );
+    if (!res.ok) {
+      result.status = res.status;
+      result.error = `getMe failed (${res.status})`;
+      return { ...result, elapsedMs: Date.now() - started };
+    }
+    const json = (await res.json()) as { id?: string; username?: string };
+    result.ok = true;
+    result.bot = {
+      id: json.id ?? null,
+      username: json.username ?? null,
+    };
+    if (includeApplication) {
+      result.application =
+        (await fetchDiscordApplicationSummary(normalized, timeoutMs, fetcher)) ?? undefined;
+    }
+    return { ...result, elapsedMs: Date.now() - started };
+  } catch (err) {
+    return {
+      ...result,
+      status: err instanceof Response ? err.status : result.status,
+      error: formatErrorMessage(err),
+      elapsedMs: Date.now() - started,
+    };
+  }
+}
+
+/**
+ * Extract the application (bot user) ID from a Discord bot token by
+ * base64-decoding the first segment.  Discord tokens have the format:
+ *   base64(user_id) . timestamp . hmac
+ * The decoded first segment is the numeric snowflake ID as a plain string,
+ * so we keep it as a string to avoid precision loss for IDs that exceed
+ * Number.MAX_SAFE_INTEGER.
+ */
+export function parseApplicationIdFromToken(token: string): string | undefined {
+  const normalized = normalizeDiscordToken(token, "channels.discord.token");
+  if (!normalized) {
+    return undefined;
+  }
+  const firstDot = normalized.indexOf(".");
+  if (firstDot <= 0) {
+    return undefined;
+  }
+  try {
+    const decoded = Buffer.from(normalized.slice(0, firstDot), "base64").toString("utf-8");
+    if (/^\d+$/.test(decoded)) {
+      return decoded;
+    }
+    return undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+export async function fetchDiscordApplicationId(
+  token: string,
+  timeoutMs: number,
+  fetcher: typeof fetch = fetch,
+): Promise<string | undefined> {
+  const normalized = normalizeDiscordToken(token, "channels.discord.token");
+  if (!normalized) {
+    return undefined;
+  }
+  const parsedApplicationId = parseApplicationIdFromToken(token);
+  if (parsedApplicationId) {
+    return parsedApplicationId;
+  }
+  try {
+    const json = await fetchDiscord<{ id?: string }>(
+      "/oauth2/applications/@me",
+      normalized,
+      createDiscordTimeoutFetch(fetcher, timeoutMs),
+    );
+    if (json?.id) {
+      return json.id;
+    }
+    return undefined;
+  } catch (error) {
+    if (error instanceof DiscordApiError) {
+      if (error.status === 429) {
+        throw error;
+      }
+      return undefined;
+    }
+    return undefined;
+  }
+}