@poolzin/pool-bot 2026.1.39 → 2026.2.1

package/dist/discord/monitor/allow-list.js

@@ -68,7 +68,7 @@ export function resolveDiscordAllowListMatch(params) {
     return { allowed: false };
 }
 export function resolveDiscordUserAllowed(params) {
-    const allowList = normalizeDiscordAllowList(params.allowList, ["discord:", "user:"]);
+    const allowList = normalizeDiscordAllowList(params.allowList, ["discord:", "user:", "pk:"]);
     if (!allowList)
         return true;
     return allowListMatches(allowList, {
@@ -80,7 +80,7 @@ export function resolveDiscordUserAllowed(params) {
 export function resolveDiscordCommandAuthorized(params) {
     if (!params.isDirectMessage)
         return true;
-    const allowList = normalizeDiscordAllowList(params.allowFrom, ["discord:", "user:"]);
+    const allowList = normalizeDiscordAllowList(params.allowFrom, ["discord:", "user:", "pk:"]);
     if (!allowList)
         return true;
     return allowListMatches(allowList, {
@@ -89,6 +89,28 @@ export function resolveDiscordCommandAuthorized(params) {
         tag: formatDiscordUserTag(params.author),
     });
 }
+export function resolveDiscordOwnerAllowFrom(params) {
+    const rawAllowList = params.channelConfig?.users ?? params.guildInfo?.users;
+    if (!Array.isArray(rawAllowList) || rawAllowList.length === 0) {
+        return undefined;
+    }
+    const allowList = normalizeDiscordAllowList(rawAllowList, ["discord:", "user:", "pk:"]);
+    if (!allowList) {
+        return undefined;
+    }
+    const match = resolveDiscordAllowListMatch({
+        allowList,
+        candidate: {
+            id: params.sender.id,
+            name: params.sender.name,
+            tag: params.sender.tag,
+        },
+    });
+    if (!match.allowed || !match.matchKey || match.matchKey === "*") {
+        return undefined;
+    }
+    return [match.matchKey];
+}
 export function resolveDiscordGuildEntry(params) {
     const guild = params.guild;
     const entries = params.guildEntries;
@@ -128,6 +150,7 @@ function resolveDiscordChannelConfigEntry(entry) {
         enabled: entry.enabled,
         users: entry.users,
         systemPrompt: entry.systemPrompt,
+        includeThreadStarter: entry.includeThreadStarter,
         autoThread: entry.autoThread,
     };
     return resolved;
@@ -199,13 +222,13 @@ export function resolveGroupDmAllow(params) {
     const { channels, channelId, channelName, channelSlug } = params;
     if (!channels || channels.length === 0)
         return true;
-    const allowList = channels.map((entry) => normalizeDiscordSlug(String(entry)));
+    const allowList = new Set(channels.map((entry) => normalizeDiscordSlug(String(entry))));
     const candidates = [
         normalizeDiscordSlug(channelId),
         channelSlug,
         channelName ? normalizeDiscordSlug(channelName) : "",
     ].filter(Boolean);
-    return allowList.includes("*") || candidates.some((candidate) => allowList.includes(candidate));
+    return allowList.has("*") || candidates.some((candidate) => allowList.has(candidate));
 }
 export function shouldEmitDiscordReactionNotification(params) {
     const mode = params.mode ?? "own";
@@ -217,7 +240,7 @@ export function shouldEmitDiscordReactionNotification(params) {
         return Boolean(params.botId && params.messageAuthorId === params.botId);
     }
     if (mode === "allowlist") {
-        const list = normalizeDiscordAllowList(params.allowlist, ["discord:", "user:"]);
+        const list = normalizeDiscordAllowList(params.allowlist, ["discord:", "user:", "pk:"]);
         if (!list)
             return false;
         return allowListMatches(list, {

package/dist/discord/monitor/gateway-registry.js

@@ -0,0 +1,29 @@
+/**
+ * Module-level registry of active Discord GatewayPlugin instances.
+ * Bridges the gap between agent tool handlers (which only have REST access)
+ * and the gateway WebSocket (needed for operations like updatePresence).
+ * Follows the same pattern as presence-cache.ts.
+ */
+const gatewayRegistry = new Map();
+// Sentinel key for the default (unnamed) account. Uses a prefix that cannot
+// collide with user-configured account IDs.
+const DEFAULT_ACCOUNT_KEY = "\0__default__";
+function resolveAccountKey(accountId) {
+    return accountId ?? DEFAULT_ACCOUNT_KEY;
+}
+/** Register a GatewayPlugin instance for an account. */
+export function registerGateway(accountId, gateway) {
+    gatewayRegistry.set(resolveAccountKey(accountId), gateway);
+}
+/** Unregister a GatewayPlugin instance for an account. */
+export function unregisterGateway(accountId) {
+    gatewayRegistry.delete(resolveAccountKey(accountId));
+}
+/** Get the GatewayPlugin for an account. Returns undefined if not registered. */
+export function getGateway(accountId) {
+    return gatewayRegistry.get(resolveAccountKey(accountId));
+}
+/** Clear all registered gateways (for testing). */
+export function clearGateways() {
+    gatewayRegistry.clear();
+}

package/dist/discord/monitor/native-command.js

@@ -1,6 +1,6 @@
 import { Button, ChannelType, Command, Row, } from "@buape/carbon";
 import { ApplicationCommandOptionType, ButtonStyle } from "discord-api-types/v10";
-import { resolveEffectiveMessagesConfig, resolveHumanDelayConfig } from "../../agents/identity.js";
+import { resolveHumanDelayConfig } from "../../agents/identity.js";
 import { resolveChunkMode, resolveTextChunkLimit } from "../../auto-reply/chunk.js";
 import { buildCommandTextFromArgs, findCommandByNativeName, listChatCommands, parseCommandArgs, resolveCommandArgChoices, resolveCommandArgMenu, serializeCommandArgs, } from "../../auto-reply/commands-registry.js";
 import { dispatchReplyWithDispatcher } from "../../auto-reply/reply/provider-dispatcher.js";
@@ -11,8 +11,10 @@ import { resolveAgentRoute } from "../../routing/resolve-route.js";
 import { loadWebMedia } from "../../web/media.js";
 import { chunkDiscordTextWithMode } from "../chunk.js";
 import { resolveCommandAuthorizedFromAuthorizers } from "../../channels/command-gating.js";
-import { allowListMatches, isDiscordGroupAllowedByPolicy, normalizeDiscordAllowList, normalizeDiscordSlug, resolveDiscordChannelConfigWithFallback, resolveDiscordGuildEntry, resolveDiscordUserAllowed, } from "./allow-list.js";
-import { formatDiscordUserTag } from "./format.js";
+import { createReplyPrefixContext } from "../../channels/reply-prefix.js";
+import { buildUntrustedChannelMetadata } from "../../security/channel-metadata.js";
+import { allowListMatches, isDiscordGroupAllowedByPolicy, normalizeDiscordAllowList, normalizeDiscordSlug, resolveDiscordChannelConfigWithFallback, resolveDiscordGuildEntry, resolveDiscordOwnerAllowFrom, resolveDiscordUserAllowed, } from "./allow-list.js";
+import { resolveDiscordSenderIdentity } from "./sender-identity.js";
 import { resolveDiscordChannelInfo } from "./message-utils.js";
 import { resolveDiscordThreadParentInfo } from "./threading.js";
 function buildDiscordCommandOptions(params) {
@@ -357,6 +359,7 @@ async function dispatchDiscordCommandInteraction(params) {
     const user = interaction.user;
     if (!user)
         return;
+    const sender = resolveDiscordSenderIdentity({ author: user, pluralkitInfo: null });
     const channel = interaction.channel;
     const channelType = channel?.type;
     const isDirectMessage = channelType === ChannelType.DM;
@@ -370,12 +373,13 @@ async function dispatchDiscordCommandInteraction(params) {
     const ownerAllowList = normalizeDiscordAllowList(discordConfig?.dm?.allowFrom ?? [], [
         "discord:",
         "user:",
+        "pk:",
     ]);
     const ownerOk = ownerAllowList && user
         ? allowListMatches(ownerAllowList, {
-            id: user.id,
-            name: user.username,
-            tag: formatDiscordUserTag(user),
+            id: sender.id,
+            name: sender.name,
+            tag: sender.tag,
         })
         : false;
     const guildInfo = resolveDiscordGuildEntry({
@@ -447,12 +451,12 @@ async function dispatchDiscordCommandInteraction(params) {
         if (dmPolicy !== "open") {
             const storeAllowFrom = await readChannelAllowFromStore("discord").catch(() => []);
             const effectiveAllowFrom = [...(discordConfig?.dm?.allowFrom ?? []), ...storeAllowFrom];
-            const allowList = normalizeDiscordAllowList(effectiveAllowFrom, ["discord:", "user:"]);
+            const allowList = normalizeDiscordAllowList(effectiveAllowFrom, ["discord:", "user:", "pk:"]);
             const permitted = allowList
                 ? allowListMatches(allowList, {
-                    id: user.id,
-                    name: user.username,
-                    tag: formatDiscordUserTag(user),
+                    id: sender.id,
+                    name: sender.name,
+                    tag: sender.tag,
                 })
                 : false;
             if (!permitted) {
@@ -462,8 +466,8 @@ async function dispatchDiscordCommandInteraction(params) {
                         channel: "discord",
                         id: user.id,
                         meta: {
-                            tag: formatDiscordUserTag(user),
-                            name: user.username ?? undefined,
+                            tag: sender.tag,
+                            name: sender.name ?? undefined,
                         },
                     });
                     if (created) {
@@ -488,9 +492,9 @@ async function dispatchDiscordCommandInteraction(params) {
         const userOk = hasUserAllowlist
             ? resolveDiscordUserAllowed({
                 allowList: channelUsers,
-                userId: user.id,
-                userName: user.username,
-                userTag: formatDiscordUserTag(user),
+                userId: sender.id,
+                userName: sender.name,
+                userTag: sender.tag,
             })
             : false;
         const authorizers = useAccessGroups
@@ -555,10 +559,17 @@ async function dispatchDiscordCommandInteraction(params) {
             kind: isDirectMessage ? "dm" : isGroupDm ? "group" : "channel",
             id: isDirectMessage ? user.id : channelId,
         },
+        parentPeer: threadParentId ? { kind: "channel", id: threadParentId } : undefined,
     });
     const conversationLabel = isDirectMessage ? (user.globalName ?? user.username) : channelId;
+    const ownerAllowFrom = resolveDiscordOwnerAllowFrom({
+        channelConfig,
+        guildInfo,
+        sender: { id: sender.id, name: sender.name, tag: sender.tag },
+    });
     const ctxPayload = finalizeInboundContext({
         Body: prompt,
+        BodyForAgent: prompt,
         RawBody: prompt,
         CommandBody: prompt,
         CommandArgs: commandArgs,
@@ -576,19 +587,25 @@ async function dispatchDiscordCommandInteraction(params) {
         GroupSubject: isGuild ? interaction.guild?.name : undefined,
         GroupSystemPrompt: isGuild
             ? (() => {
-                const channelTopic = channel && "topic" in channel ? (channel.topic ?? undefined) : undefined;
-                const channelDescription = channelTopic?.trim();
-                const systemPromptParts = [
-                    channelDescription ? `Channel topic: ${channelDescription}` : null,
-                    channelConfig?.systemPrompt?.trim() || null,
-                ].filter((entry) => Boolean(entry));
+                const systemPromptParts = [channelConfig?.systemPrompt?.trim() || null].filter((entry) => Boolean(entry));
                 return systemPromptParts.length > 0 ? systemPromptParts.join("\n\n") : undefined;
             })()
             : undefined,
+        UntrustedContext: isGuild
+            ? (() => {
+                const channelTopic = channel && "topic" in channel ? (channel.topic ?? undefined) : undefined;
+                const untrustedChannelMetadata = buildUntrustedChannelMetadata({
+                    source: "discord",
+                    label: "Discord channel topic",
+                    entries: [channelTopic],
+                });
+                return untrustedChannelMetadata ? [untrustedChannelMetadata] : undefined;
+            })()
+            : undefined,
         SenderName: user.globalName ?? user.username,
         SenderId: user.id,
         SenderUsername: user.username,
-        SenderTag: formatDiscordUserTag(user),
+        SenderTag: sender.tag,
         Provider: "discord",
         Surface: "discord",
         WasMentioned: true,
@@ -596,13 +613,16 @@ async function dispatchDiscordCommandInteraction(params) {
         Timestamp: Date.now(),
         CommandAuthorized: commandAuthorized,
         CommandSource: "native",
+        OwnerAllowFrom: ownerAllowFrom,
     });
+    const prefixContext = createReplyPrefixContext({ cfg, agentId: route.agentId });
     let didReply = false;
     await dispatchReplyWithDispatcher({
         ctx: ctxPayload,
         cfg,
         dispatcherOptions: {
-            responsePrefix: resolveEffectiveMessagesConfig(cfg, route.agentId).responsePrefix,
+            responsePrefix: prefixContext.responsePrefix,
+            responsePrefixContextProvider: prefixContext.responsePrefixContextProvider,
             humanDelay: resolveHumanDelayConfig(cfg, route.agentId),
             deliver: async (payload) => {
                 try {
@@ -635,6 +655,7 @@ async function dispatchDiscordCommandInteraction(params) {
             disableBlockStreaming: typeof discordConfig?.blockStreaming === "boolean"
                 ? !discordConfig.blockStreaming
                 : undefined,
+            onModelSelected: prefixContext.onModelSelected,
         },
     });
 }

package/dist/discord/monitor/sender-identity.js

@@ -0,0 +1,45 @@
+import { formatDiscordUserTag } from "./format.js";
+export function resolveDiscordWebhookId(message) {
+    const candidate = message.webhookId ?? message.webhook_id;
+    return typeof candidate === "string" && candidate.trim() ? candidate.trim() : null;
+}
+export function resolveDiscordSenderIdentity(params) {
+    const pkInfo = params.pluralkitInfo ?? null;
+    const pkMember = pkInfo?.member ?? undefined;
+    const pkSystem = pkInfo?.system ?? undefined;
+    const memberId = pkMember?.id?.trim();
+    const memberNameRaw = pkMember?.display_name ?? pkMember?.name ?? "";
+    const memberName = memberNameRaw?.trim();
+    if (memberId && memberName) {
+        const systemName = pkSystem?.name?.trim();
+        const label = systemName ? `${memberName} (PK:${systemName})` : `${memberName} (PK)`;
+        return {
+            id: memberId,
+            name: memberName,
+            tag: pkMember?.name?.trim() || undefined,
+            label,
+            isPluralKit: true,
+            pluralkit: {
+                memberId,
+                memberName,
+                systemId: pkSystem?.id?.trim() || undefined,
+                systemName,
+            },
+        };
+    }
+    const senderTag = formatDiscordUserTag(params.author);
+    const senderDisplay = params.member?.nickname ?? params.author.globalName ?? params.author.username;
+    const senderLabel = senderDisplay && senderTag && senderDisplay !== senderTag
+        ? `${senderDisplay} (${senderTag})`
+        : (senderDisplay ?? senderTag ?? params.author.id);
+    return {
+        id: params.author.id,
+        name: params.author.username ?? undefined,
+        tag: senderTag,
+        label: senderLabel,
+        isPluralKit: false,
+    };
+}
+export function resolveDiscordSenderLabel(params) {
+    return resolveDiscordSenderIdentity(params).label;
+}

package/dist/discord/pluralkit.js

@@ -0,0 +1,27 @@
+import { resolveFetch } from "../infra/fetch.js";
+const PLURALKIT_API_BASE = "https://api.pluralkit.me/v2";
+export async function fetchPluralKitMessageInfo(params) {
+    if (!params.config?.enabled) {
+        return null;
+    }
+    const fetchImpl = resolveFetch(params.fetcher);
+    if (!fetchImpl) {
+        return null;
+    }
+    const headers = {};
+    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());
+}

package/dist/discord/send.outbound.js

@@ -1,11 +1,25 @@
-import { Routes } from "discord-api-types/v10";
+import { ChannelType, Routes } from "discord-api-types/v10";
 import { resolveChunkMode } from "../auto-reply/chunk.js";
 import { loadConfig } from "../config/config.js";
 import { resolveMarkdownTableMode } from "../config/markdown-tables.js";
 import { recordChannelActivity } from "../infra/channel-activity.js";
 import { convertMarkdownTables } from "../markdown/tables.js";
 import { resolveDiscordAccount } from "./accounts.js";
-import { buildDiscordSendError, createDiscordClient, normalizeDiscordPollInput, normalizeStickerIds, parseRecipient, resolveChannelId, sendDiscordMedia, sendDiscordText, } from "./send.shared.js";
+import { buildDiscordSendError, buildDiscordTextChunks, createDiscordClient, normalizeDiscordPollInput, normalizeStickerIds, parseAndResolveRecipient, resolveChannelId, sendDiscordMedia, sendDiscordText, } from "./send.shared.js";
+/** Discord thread names are capped at 100 characters. */
+const DISCORD_THREAD_NAME_LIMIT = 100;
+/** Derive a thread title from the first non-empty line of the message text. */
+function deriveForumThreadName(text) {
+    const firstLine = text
+        .split("\n")
+        .find((l) => l.trim())
+        ?.trim() ?? "";
+    return firstLine.slice(0, DISCORD_THREAD_NAME_LIMIT) || new Date().toISOString().slice(0, 16);
+}
+/** Forum/Media channels cannot receive regular messages; detect them here. */
+function isForumLikeType(channelType) {
+    return channelType === ChannelType.GuildForum || channelType === ChannelType.GuildMedia;
+}
 export async function sendMessageDiscord(to, text, opts = {}) {
     const cfg = loadConfig();
     const accountInfo = resolveDiscordAccount({
@@ -20,8 +34,81 @@ export async function sendMessageDiscord(to, text, opts = {}) {
     const chunkMode = resolveChunkMode(cfg, "discord", accountInfo.accountId);
     const textWithTables = convertMarkdownTables(text ?? "", tableMode);
     const { token, rest, request } = createDiscordClient(opts, cfg);
-    const recipient = parseRecipient(to);
+    const recipient = await parseAndResolveRecipient(to, opts.accountId);
     const { channelId } = await resolveChannelId(rest, recipient, request);
+    // Forum/Media channels reject POST /messages; auto-create a thread post instead.
+    let channelType;
+    try {
+        const channel = (await rest.get(Routes.channel(channelId)));
+        channelType = channel?.type;
+    }
+    catch {
+        // If we can't fetch the channel, fall through to the normal send path.
+    }
+    if (isForumLikeType(channelType)) {
+        const threadName = deriveForumThreadName(textWithTables);
+        const chunks = buildDiscordTextChunks(textWithTables, {
+            maxLinesPerMessage: accountInfo.config.maxLinesPerMessage,
+            chunkMode,
+        });
+        const starterContent = chunks[0]?.trim() ? chunks[0] : threadName;
+        const starterEmbeds = opts.embeds?.length ? opts.embeds : undefined;
+        let threadRes;
+        try {
+            threadRes = (await request(() => rest.post(Routes.threads(channelId), {
+                body: {
+                    name: threadName,
+                    message: {
+                        content: starterContent,
+                        ...(starterEmbeds ? { embeds: starterEmbeds } : {}),
+                    },
+                },
+            }), "forum-thread"));
+        }
+        catch (err) {
+            throw await buildDiscordSendError(err, {
+                channelId,
+                rest,
+                token,
+                hasMedia: Boolean(opts.mediaUrl),
+            });
+        }
+        const threadId = threadRes.id;
+        const messageId = threadRes.message?.id ?? threadId;
+        const resultChannelId = threadRes.message?.channel_id ?? threadId;
+        const remainingChunks = chunks.slice(1);
+        try {
+            if (opts.mediaUrl) {
+                const [mediaCaption, ...afterMediaChunks] = remainingChunks;
+                await sendDiscordMedia(rest, threadId, mediaCaption ?? "", opts.mediaUrl, undefined, request, accountInfo.config.maxLinesPerMessage, undefined, chunkMode);
+                for (const chunk of afterMediaChunks) {
+                    await sendDiscordText(rest, threadId, chunk, undefined, request, accountInfo.config.maxLinesPerMessage, undefined, chunkMode);
+                }
+            }
+            else {
+                for (const chunk of remainingChunks) {
+                    await sendDiscordText(rest, threadId, chunk, undefined, request, accountInfo.config.maxLinesPerMessage, undefined, chunkMode);
+                }
+            }
+        }
+        catch (err) {
+            throw await buildDiscordSendError(err, {
+                channelId: threadId,
+                rest,
+                token,
+                hasMedia: Boolean(opts.mediaUrl),
+            });
+        }
+        recordChannelActivity({
+            channel: "discord",
+            accountId: accountInfo.accountId,
+            direction: "outbound",
+        });
+        return {
+            messageId: messageId ? String(messageId) : "unknown",
+            channelId: String(resultChannelId ?? channelId),
+        };
+    }
     let result;
     try {
         if (opts.mediaUrl) {
@@ -52,7 +139,7 @@ export async function sendMessageDiscord(to, text, opts = {}) {
 export async function sendStickerDiscord(to, stickerIds, opts = {}) {
     const cfg = loadConfig();
     const { rest, request } = createDiscordClient(opts, cfg);
-    const recipient = parseRecipient(to);
+    const recipient = await parseAndResolveRecipient(to, opts.accountId);
     const { channelId } = await resolveChannelId(rest, recipient, request);
     const content = opts.content?.trim();
     const stickers = normalizeStickerIds(stickerIds);
@@ -70,7 +157,7 @@ export async function sendStickerDiscord(to, stickerIds, opts = {}) {
 export async function sendPollDiscord(to, poll, opts = {}) {
     const cfg = loadConfig();
     const { rest, request } = createDiscordClient(opts, cfg);
-    const recipient = parseRecipient(to);
+    const recipient = await parseAndResolveRecipient(to, opts.accountId);
     const { channelId } = await resolveChannelId(rest, recipient, request);
     const content = opts.content?.trim();
     const payload = normalizeDiscordPollInput(poll);

package/dist/discord/send.shared.js

@@ -9,7 +9,7 @@ import { resolveDiscordAccount } from "./accounts.js";
 import { chunkDiscordTextWithMode } from "./chunk.js";
 import { fetchChannelPermissionsDiscord, isThreadChannelType } from "./send.permissions.js";
 import { DiscordSendError } from "./send.types.js";
-import { parseDiscordTarget } from "./targets.js";
+import { parseDiscordTarget, resolveDiscordTarget } from "./targets.js";
 import { normalizeDiscordToken } from "./token.js";
 const DISCORD_TEXT_LIMIT = 2000;
 const DISCORD_MAX_STICKERS = 3;
@@ -19,8 +19,9 @@ const DISCORD_MISSING_PERMISSIONS = 50013;
 const DISCORD_CANNOT_DM = 50007;
 function resolveToken(params) {
     const explicit = normalizeDiscordToken(params.explicit);
-    if (explicit)
+    if (explicit) {
         return explicit;
+    }
     const fallback = normalizeDiscordToken(params.fallbackToken);
     if (!fallback) {
         throw new Error(`Discord bot token missing for account "${params.accountId}" (set discord.accounts.${params.accountId}.token or DISCORD_BOT_TOKEN for default).`);
@@ -68,6 +69,37 @@ function parseRecipient(raw) {
     }
     return { kind: target.kind, id: target.id };
 }
+/**
+ * Parse and resolve Discord recipient, including username lookup.
+ * This enables sending DMs by username (e.g., "john.doe") by querying
+ * the Discord directory to resolve usernames to user IDs.
+ *
+ * @param raw - The recipient string (username, ID, or known format)
+ * @param accountId - Discord account ID to use for directory lookup
+ * @returns Parsed DiscordRecipient with resolved user ID if applicable
+ */
+export async function parseAndResolveRecipient(raw, accountId) {
+    const cfg = loadConfig();
+    const accountInfo = resolveDiscordAccount({ cfg, accountId });
+    // First try to resolve using directory lookup (handles usernames)
+    const trimmed = raw.trim();
+    const parseOptions = {
+        ambiguousMessage: `Ambiguous Discord recipient "${trimmed}". Use "user:${trimmed}" for DMs or "channel:${trimmed}" for channel messages.`,
+    };
+    const resolved = await resolveDiscordTarget(raw, {
+        cfg,
+        accountId: accountInfo.accountId,
+    }, parseOptions);
+    if (resolved) {
+        return { kind: resolved.kind, id: resolved.id };
+    }
+    // Fallback to standard parsing (for channels, etc.)
+    const parsed = parseDiscordTarget(raw, parseOptions);
+    if (!parsed) {
+        throw new Error("Recipient is required for Discord sends");
+    }
+    return { kind: parsed.kind, id: parsed.id };
+}
 function normalizeStickerIds(raw) {
     const ids = raw.map((entry) => entry.trim()).filter(Boolean);
     if (ids.length === 0) {
@@ -102,29 +134,33 @@ function normalizeDiscordPollInput(input) {
     };
 }
 function getDiscordErrorCode(err) {
-    if (!err || typeof err !== "object")
+    if (!err || typeof err !== "object") {
         return undefined;
+    }
     const candidate = "code" in err && err.code !== undefined
         ? err.code
         : "rawError" in err && err.rawError && typeof err.rawError === "object"
             ? err.rawError.code
             : undefined;
-    if (typeof candidate === "number")
+    if (typeof candidate === "number") {
         return candidate;
+    }
     if (typeof candidate === "string" && /^\d+$/.test(candidate)) {
         return Number(candidate);
     }
     return undefined;
 }
 async function buildDiscordSendError(err, ctx) {
-    if (err instanceof DiscordSendError)
+    if (err instanceof DiscordSendError) {
         return err;
+    }
     const code = getDiscordErrorCode(err);
     if (code === DISCORD_CANNOT_DM) {
         return new DiscordSendError("discord dm failed: user blocks dms or privacy settings disallow it", { kind: "dm-blocked" });
     }
-    if (code !== DISCORD_MISSING_PERMISSIONS)
+    if (code !== DISCORD_MISSING_PERMISSIONS) {
         return err;
+    }
     let missing = [];
     try {
         const permissions = await fetchChannelPermissionsDiscord(ctx.channelId, {
@@ -165,18 +201,26 @@ async function resolveChannelId(rest, recipient, request) {
     }
     return { channelId: dmChannel.id, dm: true };
 }
+export function buildDiscordTextChunks(text, opts = {}) {
+    if (!text) {
+        return [];
+    }
+    const chunks = chunkDiscordTextWithMode(text, {
+        maxChars: opts.maxChars ?? DISCORD_TEXT_LIMIT,
+        maxLines: opts.maxLinesPerMessage,
+        chunkMode: opts.chunkMode,
+    });
+    if (!chunks.length && text) {
+        chunks.push(text);
+    }
+    return chunks;
+}
 async function sendDiscordText(rest, channelId, text, replyTo, request, maxLinesPerMessage, embeds, chunkMode) {
     if (!text.trim()) {
         throw new Error("Message must be non-empty for Discord sends");
     }
     const messageReference = replyTo ? { message_id: replyTo, fail_if_not_exists: false } : undefined;
-    const chunks = chunkDiscordTextWithMode(text, {
-        maxChars: DISCORD_TEXT_LIMIT,
-        maxLines: maxLinesPerMessage,
-        chunkMode,
-    });
-    if (!chunks.length && text)
-        chunks.push(text);
+    const chunks = buildDiscordTextChunks(text, { maxLinesPerMessage, chunkMode });
     if (chunks.length === 1) {
         const res = (await request(() => rest.post(Routes.channelMessages(channelId), {
             body: {
@@ -206,15 +250,7 @@ async function sendDiscordText(rest, channelId, text, replyTo, request, maxLines
 }
 async function sendDiscordMedia(rest, channelId, text, mediaUrl, replyTo, request, maxLinesPerMessage, embeds, chunkMode) {
     const media = await loadWebMedia(mediaUrl);
-    const chunks = text
-        ? chunkDiscordTextWithMode(text, {
-            maxChars: DISCORD_TEXT_LIMIT,
-            maxLines: maxLinesPerMessage,
-            chunkMode,
-        })
-        : [];
-    if (!chunks.length && text)
-        chunks.push(text);
+    const chunks = text ? buildDiscordTextChunks(text, { maxLinesPerMessage, chunkMode }) : [];
     const caption = chunks[0] ?? "";
     const messageReference = replyTo ? { message_id: replyTo, fail_if_not_exists: false } : undefined;
     const res = (await request(() => rest.post(Routes.channelMessages(channelId), {
@@ -231,8 +267,9 @@ async function sendDiscordMedia(rest, channelId, text, mediaUrl, replyTo, reques
         },
     }), "media"));
     for (const chunk of chunks.slice(1)) {
-        if (!chunk.trim())
+        if (!chunk.trim()) {
             continue;
+        }
         await sendDiscordText(rest, channelId, chunk, undefined, request, maxLinesPerMessage, undefined, chunkMode);
     }
     return res;