@poolzin/pool-bot 2026.2.21 → 2026.2.23

package/dist/discord/monitor/provider.js

@@ -1,17 +1,17 @@
 import { inspect } from "node:util";
-import { Client } from "@buape/carbon";
-import { GatewayIntents, GatewayPlugin } from "@buape/carbon/gateway";
+import { Client, ReadyListener, } from "@buape/carbon";
 import { Routes } from "discord-api-types/v10";
 import { resolveTextChunkLimit } from "../../auto-reply/chunk.js";
 import { listNativeCommandSpecsForConfig } from "../../auto-reply/commands-registry.js";
 import { listSkillCommandsForAgents } from "../../auto-reply/skill-commands.js";
-import { mergeAllowlist, summarizeMapping } from "../../channels/allowlists/resolve-utils.js";
+import { addAllowlistUserEntriesFromConfigEntry, buildAllowlistResolutionSummary, mergeAllowlist, resolveAllowlistIdAdditions, patchAllowlistUsersInConfigEntries, summarizeMapping, } from "../../channels/allowlists/resolve-utils.js";
 import { isNativeCommandsExplicitlyDisabled, resolveNativeCommandsEnabled, resolveNativeSkillsEnabled, } from "../../config/commands.js";
 import { loadConfig } from "../../config/config.js";
 import { danger, logVerbose, shouldLogVerbose, warn } from "../../globals.js";
 import { formatErrorMessage } from "../../infra/errors.js";
 import { createDiscordRetryRunner } from "../../infra/retry-policy.js";
 import { createSubsystemLogger } from "../../logging/subsystem.js";
+import { createNonExitingRuntime } from "../../runtime.js";
 import { resolveDiscordAccount } from "../accounts.js";
 import { attachDiscordGatewayLogging } from "../gateway-logging.js";
 import { getDiscordGatewayEmitter, waitForDiscordGatewayStop } from "../monitor.gateway.js";
@@ -19,28 +19,53 @@ import { fetchDiscordApplicationId } from "../probe.js";
 import { resolveDiscordChannelAllowlist } from "../resolve-channels.js";
 import { resolveDiscordUserAllowlist } from "../resolve-users.js";
 import { normalizeDiscordToken } from "../token.js";
+import { createAgentComponentButton, createAgentSelectMenu, createDiscordComponentButton, createDiscordComponentChannelSelect, createDiscordComponentMentionableSelect, createDiscordComponentModal, createDiscordComponentRoleSelect, createDiscordComponentStringSelect, createDiscordComponentUserSelect, } from "./agent-components.js";
+import { createExecApprovalButton, DiscordExecApprovalHandler } from "./exec-approvals.js";
+import { createDiscordGatewayPlugin } from "./gateway-plugin.js";
+import { registerGateway, unregisterGateway } from "./gateway-registry.js";
 import { DiscordMessageListener, DiscordPresenceListener, DiscordReactionListener, DiscordReactionRemoveListener, registerDiscordListener, } from "./listeners.js";
 import { createDiscordMessageHandler } from "./message-handler.js";
 import { createDiscordCommandArgFallbackButton, createDiscordNativeCommand, } from "./native-command.js";
-import { createExecApprovalButton, DiscordExecApprovalHandler } from "./exec-approvals.js";
+import { resolveDiscordPresenceUpdate } from "./presence.js";
+import { resolveDiscordRestFetch } from "./rest-fetch.js";
 function summarizeAllowList(list) {
-    if (!list || list.length === 0)
+    if (!list || list.length === 0) {
         return "any";
+    }
     const sample = list.slice(0, 4).map((entry) => String(entry));
     const suffix = list.length > sample.length ? ` (+${list.length - sample.length})` : "";
     return `${sample.join(", ")}${suffix}`;
 }
 function summarizeGuilds(entries) {
-    if (!entries || Object.keys(entries).length === 0)
+    if (!entries || Object.keys(entries).length === 0) {
         return "any";
+    }
     const keys = Object.keys(entries);
     const sample = keys.slice(0, 4);
     const suffix = keys.length > sample.length ? ` (+${keys.length - sample.length})` : "";
     return `${sample.join(", ")}${suffix}`;
 }
+function dedupeSkillCommandsForDiscord(skillCommands) {
+    const seen = new Set();
+    const deduped = [];
+    for (const command of skillCommands) {
+        const key = command.skillName.trim().toLowerCase();
+        if (!key) {
+            deduped.push(command);
+            continue;
+        }
+        if (seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        deduped.push(command);
+    }
+    return deduped;
+}
 async function deployDiscordCommands(params) {
-    if (!params.enabled)
+    if (!params.enabled) {
         return;
+    }
     const runWithRetry = createDiscordRetryRunner({ verbose: shouldLogVerbose() });
     try {
         await runWithRetry(() => params.client.handleDeployRequest(), "command deploy");
@@ -51,14 +76,16 @@ async function deployDiscordCommands(params) {
     }
 }
 function formatDiscordDeployErrorDetails(err) {
-    if (!err || typeof err !== "object")
+    if (!err || typeof err !== "object") {
         return "";
+    }
     const status = err.status;
     const discordCode = err.discordCode;
     const rawBody = err.rawBody;
     const details = [];
-    if (typeof status === "number")
+    if (typeof status === "number") {
         details.push(`status=${status}`);
+    }
     if (typeof discordCode === "number" || typeof discordCode === "string") {
         details.push(`code=${discordCode}`);
     }
@@ -79,21 +106,6 @@ function formatDiscordDeployErrorDetails(err) {
     }
     return details.length > 0 ? ` (${details.join(", ")})` : "";
 }
-function resolveDiscordGatewayIntents(intentsConfig) {
-    let intents = GatewayIntents.Guilds |
-        GatewayIntents.GuildMessages |
-        GatewayIntents.MessageContent |
-        GatewayIntents.DirectMessages |
-        GatewayIntents.GuildMessageReactions |
-        GatewayIntents.DirectMessageReactions;
-    if (intentsConfig?.presence) {
-        intents |= GatewayIntents.GuildPresences;
-    }
-    if (intentsConfig?.guildMembers) {
-        intents |= GatewayIntents.GuildMembers;
-    }
-    return intents;
-}
 export async function monitorDiscordProvider(opts = {}) {
     const cfg = opts.config ?? loadConfig();
     const account = resolveDiscordAccount({
@@ -104,14 +116,9 @@ export async function monitorDiscordProvider(opts = {}) {
     if (!token) {
         throw new Error(`Discord bot token missing for account "${account.accountId}" (set discord.accounts.${account.accountId}.token or DISCORD_BOT_TOKEN for default).`);
     }
-    const runtime = opts.runtime ?? {
-        log: console.log,
-        error: console.error,
-        exit: (code) => {
-            throw new Error(`exit ${code}`);
-        },
-    };
+    const runtime = opts.runtime ?? createNonExitingRuntime();
     const discordCfg = account.config;
+    const discordRestFetch = resolveDiscordRestFetch(discordCfg.proxy, runtime);
     const dmConfig = discordCfg.dm;
     let guildEntries = discordCfg.guilds;
     const defaultGroupPolicy = cfg.channels?.defaults?.groupPolicy;
@@ -122,7 +129,7 @@ export async function monitorDiscordProvider(opts = {}) {
         groupPolicy === "open") {
         runtime.log?.(warn('discord: groupPolicy defaults to "open" when channels.discord is missing; set channels.discord.groupPolicy (or channels.defaults.groupPolicy) or add channels.discord.guilds to restrict access.'));
     }
-    let allowFrom = dmConfig?.allowFrom;
+    let allowFrom = discordCfg.allowFrom ?? dmConfig?.allowFrom;
     const mediaMaxBytes = (opts.mediaMaxMb ?? discordCfg.mediaMaxMb ?? 8) * 1024 * 1024;
     const textLimit = resolveTextChunkLimit(cfg, "discord", account.accountId, {
         fallbackLimit: 2000,
@@ -130,7 +137,7 @@ export async function monitorDiscordProvider(opts = {}) {
     const historyLimit = Math.max(0, opts.historyLimit ?? discordCfg.historyLimit ?? cfg.messages?.groupChat?.historyLimit ?? 20);
     const replyToMode = opts.replyToMode ?? discordCfg.replyToMode ?? "off";
     const dmEnabled = dmConfig?.enabled ?? true;
-    const dmPolicy = dmConfig?.policy ?? "pairing";
+    const dmPolicy = discordCfg.dmPolicy ?? dmConfig?.policy ?? "pairing";
     const groupDmEnabled = dmConfig?.groupEnabled ?? false;
     const groupDmChannels = dmConfig?.groupChannels;
     const nativeEnabled = resolveNativeCommandsEnabled({
@@ -155,12 +162,14 @@ export async function monitorDiscordProvider(opts = {}) {
             try {
                 const entries = [];
                 for (const [guildKey, guildCfg] of Object.entries(guildEntries)) {
-                    if (guildKey === "*")
+                    if (guildKey === "*") {
                         continue;
+                    }
                     const channels = guildCfg?.channels ?? {};
                     const channelKeys = Object.keys(channels).filter((key) => key !== "*");
                     if (channelKeys.length === 0) {
-                        entries.push({ input: guildKey, guildKey });
+                        const input = /^\d+$/.test(guildKey) ? `guild:${guildKey}` : guildKey;
+                        entries.push({ input, guildKey });
                         continue;
                     }
                     for (const channelKey of channelKeys) {
@@ -175,14 +184,16 @@ export async function monitorDiscordProvider(opts = {}) {
                     const resolved = await resolveDiscordChannelAllowlist({
                         token,
                         entries: entries.map((entry) => entry.input),
+                        fetcher: discordRestFetch,
                     });
                     const nextGuilds = { ...guildEntries };
                     const mapping = [];
                     const unresolved = [];
                     for (const entry of resolved) {
                         const source = entries.find((item) => item.input === entry.input);
-                        if (!source)
+                        if (!source) {
                             continue;
+                        }
                         const sourceGuild = guildEntries?.[source.guildKey] ?? {};
                         if (!entry.resolved || !entry.guildId) {
                             unresolved.push(entry.input);
@@ -225,19 +236,9 @@ export async function monitorDiscordProvider(opts = {}) {
                 const resolvedUsers = await resolveDiscordUserAllowlist({
                     token,
                     entries: allowEntries.map((entry) => String(entry)),
+                    fetcher: discordRestFetch,
                 });
-                const mapping = [];
-                const unresolved = [];
-                const additions = [];
-                for (const entry of resolvedUsers) {
-                    if (entry.resolved && entry.id) {
-                        mapping.push(`${entry.input}→${entry.id}`);
-                        additions.push(entry.id);
-                    }
-                    else {
-                        unresolved.push(entry.input);
-                    }
-                }
+                const { mapping, unresolved, additions } = buildAllowlistResolutionSummary(resolvedUsers);
                 allowFrom = mergeAllowlist({ existing: allowFrom, additions });
                 summarizeMapping("discord users", mapping, unresolved, runtime);
             }
@@ -248,28 +249,13 @@ export async function monitorDiscordProvider(opts = {}) {
         if (guildEntries && Object.keys(guildEntries).length > 0) {
             const userEntries = new Set();
             for (const guild of Object.values(guildEntries)) {
-                if (!guild || typeof guild !== "object")
+                if (!guild || typeof guild !== "object") {
                     continue;
-                const users = guild.users;
-                if (Array.isArray(users)) {
-                    for (const entry of users) {
-                        const trimmed = String(entry).trim();
-                        if (trimmed && trimmed !== "*")
-                            userEntries.add(trimmed);
-                    }
                 }
+                addAllowlistUserEntriesFromConfigEntry(userEntries, guild);
                 const channels = guild.channels ?? {};
                 for (const channel of Object.values(channels)) {
-                    if (!channel || typeof channel !== "object")
-                        continue;
-                    const channelUsers = channel.users;
-                    if (!Array.isArray(channelUsers))
-                        continue;
-                    for (const entry of channelUsers) {
-                        const trimmed = String(entry).trim();
-                        if (trimmed && trimmed !== "*")
-                            userEntries.add(trimmed);
-                    }
+                    addAllowlistUserEntriesFromConfigEntry(userEntries, channel);
                 }
             }
             if (userEntries.size > 0) {
@@ -277,52 +263,26 @@ export async function monitorDiscordProvider(opts = {}) {
                     const resolvedUsers = await resolveDiscordUserAllowlist({
                         token,
                         entries: Array.from(userEntries),
+                        fetcher: discordRestFetch,
                     });
-                    const resolvedMap = new Map(resolvedUsers.map((entry) => [entry.input, entry]));
-                    const mapping = resolvedUsers
-                        .filter((entry) => entry.resolved && entry.id)
-                        .map((entry) => `${entry.input}→${entry.id}`);
-                    const unresolved = resolvedUsers
-                        .filter((entry) => !entry.resolved)
-                        .map((entry) => entry.input);
+                    const { resolvedMap, mapping, unresolved } = buildAllowlistResolutionSummary(resolvedUsers);
                     const nextGuilds = { ...guildEntries };
                     for (const [guildKey, guildConfig] of Object.entries(guildEntries ?? {})) {
-                        if (!guildConfig || typeof guildConfig !== "object")
+                        if (!guildConfig || typeof guildConfig !== "object") {
                             continue;
+                        }
                         const nextGuild = { ...guildConfig };
                         const users = guildConfig.users;
                         if (Array.isArray(users) && users.length > 0) {
-                            const additions = [];
-                            for (const entry of users) {
-                                const trimmed = String(entry).trim();
-                                const resolved = resolvedMap.get(trimmed);
-                                if (resolved?.resolved && resolved.id)
-                                    additions.push(resolved.id);
-                            }
+                            const additions = resolveAllowlistIdAdditions({ existing: users, resolvedMap });
                             nextGuild.users = mergeAllowlist({ existing: users, additions });
                         }
                         const channels = guildConfig.channels ?? {};
                         if (channels && typeof channels === "object") {
-                            const nextChannels = { ...channels };
-                            for (const [channelKey, channelConfig] of Object.entries(channels)) {
-                                if (!channelConfig || typeof channelConfig !== "object")
-                                    continue;
-                                const channelUsers = channelConfig.users;
-                                if (!Array.isArray(channelUsers) || channelUsers.length === 0)
-                                    continue;
-                                const additions = [];
-                                for (const entry of channelUsers) {
-                                    const trimmed = String(entry).trim();
-                                    const resolved = resolvedMap.get(trimmed);
-                                    if (resolved?.resolved && resolved.id)
-                                        additions.push(resolved.id);
-                                }
-                                nextChannels[channelKey] = {
-                                    ...channelConfig,
-                                    users: mergeAllowlist({ existing: channelUsers, additions }),
-                                };
-                            }
-                            nextGuild.channels = nextChannels;
+                            nextGuild.channels = patchAllowlistUsersInConfigEntries({
+                                entries: channels,
+                                resolvedMap,
+                            });
                         }
                         nextGuilds[guildKey] = nextGuild;
                     }
@@ -338,12 +298,14 @@ export async function monitorDiscordProvider(opts = {}) {
     if (shouldLogVerbose()) {
         logVerbose(`discord: config dm=${dmEnabled ? "on" : "off"} dmPolicy=${dmPolicy} allowFrom=${summarizeAllowList(allowFrom)} groupDm=${groupDmEnabled ? "on" : "off"} groupDmChannels=${summarizeAllowList(groupDmChannels)} groupPolicy=${groupPolicy} guilds=${summarizeGuilds(guildEntries)} historyLimit=${historyLimit} mediaMaxMb=${Math.round(mediaMaxBytes / (1024 * 1024))} native=${nativeEnabled ? "on" : "off"} nativeSkills=${nativeSkillsEnabled ? "on" : "off"} accessGroups=${useAccessGroups ? "on" : "off"}`);
     }
-    const applicationId = await fetchDiscordApplicationId(token, 4000);
+    const applicationId = await fetchDiscordApplicationId(token, 4000, discordRestFetch);
     if (!applicationId) {
         throw new Error("Failed to resolve Discord application id");
     }
     const maxDiscordCommands = 100;
-    let skillCommands = nativeEnabled && nativeSkillsEnabled ? listSkillCommandsForAgents({ cfg }) : [];
+    let skillCommands = nativeEnabled && nativeSkillsEnabled
+        ? dedupeSkillCommandsForDiscord(listSkillCommandsForAgents({ cfg }))
+        : [];
     let commandSpecs = nativeEnabled
         ? listNativeCommandSpecsForConfig(cfg, { skillCommands, provider: "discord" })
         : [];
@@ -375,6 +337,8 @@ export async function monitorDiscordProvider(opts = {}) {
             runtime,
         })
         : null;
+    const agentComponentsConfig = discordCfg.agentComponents ?? {};
+    const agentComponentsEnabled = agentComponentsConfig.enabled ?? true;
     const components = [
         createDiscordCommandArgFallbackButton({
             cfg,
@@ -383,9 +347,44 @@ export async function monitorDiscordProvider(opts = {}) {
             sessionPrefix,
         }),
     ];
+    const modals = [];
     if (execApprovalsHandler) {
         components.push(createExecApprovalButton({ handler: execApprovalsHandler }));
     }
+    if (agentComponentsEnabled) {
+        const componentContext = {
+            cfg,
+            discordConfig: discordCfg,
+            accountId: account.accountId,
+            guildEntries,
+            allowFrom,
+            dmPolicy,
+            runtime,
+            token,
+        };
+        components.push(createAgentComponentButton(componentContext));
+        components.push(createAgentSelectMenu(componentContext));
+        components.push(createDiscordComponentButton(componentContext));
+        components.push(createDiscordComponentStringSelect(componentContext));
+        components.push(createDiscordComponentUserSelect(componentContext));
+        components.push(createDiscordComponentRoleSelect(componentContext));
+        components.push(createDiscordComponentMentionableSelect(componentContext));
+        components.push(createDiscordComponentChannelSelect(componentContext));
+        modals.push(createDiscordComponentModal(componentContext));
+    }
+    class DiscordStatusReadyListener extends ReadyListener {
+        async handle(_data, client) {
+            const gateway = client.getPlugin("gateway");
+            if (!gateway) {
+                return;
+            }
+            const presence = resolveDiscordPresenceUpdate(discordCfg);
+            if (!presence) {
+                return;
+            }
+            gateway.updatePresence(presence);
+        }
+    }
     const client = new Client({
         baseUrl: "http://localhost",
         deploySecret: "a",
@@ -395,17 +394,10 @@ export async function monitorDiscordProvider(opts = {}) {
         autoDeploy: false,
     }, {
         commands,
-        listeners: [],
+        listeners: [new DiscordStatusReadyListener()],
         components,
-    }, [
-        new GatewayPlugin({
-            reconnect: {
-                maxAttempts: Number.POSITIVE_INFINITY,
-            },
-            intents: resolveDiscordGatewayIntents(discordCfg.intents),
-            autoInteractions: true,
-        }),
-    ]);
+        modals,
+    }, [createDiscordGatewayPlugin({ discordConfig: discordCfg, runtime })]);
     await deployDiscordCommands({ client, runtime, enabled: nativeEnabled });
     const logger = createSubsystemLogger("discord/monitor");
     const guildHistories = new Map();
@@ -469,6 +461,9 @@ export async function monitorDiscordProvider(opts = {}) {
         await execApprovalsHandler.start();
     }
     const gateway = client.getPlugin("gateway");
+    if (gateway) {
+        registerGateway(account.accountId, gateway);
+    }
     const gatewayEmitter = getDiscordGatewayEmitter(gateway);
     const stopGatewayLogging = attachDiscordGatewayLogging({
         emitter: gatewayEmitter,
@@ -476,8 +471,9 @@ export async function monitorDiscordProvider(opts = {}) {
     });
     const abortSignal = opts.abortSignal;
     const onAbort = () => {
-        if (!gateway)
+        if (!gateway) {
             return;
+        }
         // Carbon emits an error when maxAttempts is 0; keep a one-shot listener to avoid
         // an unhandled error after we tear down listeners during abort.
         gatewayEmitter?.once("error", () => { });
@@ -495,10 +491,12 @@ export async function monitorDiscordProvider(opts = {}) {
     let helloTimeoutId;
     const onGatewayDebug = (msg) => {
         const message = String(msg);
-        if (!message.includes("WebSocket connection opened"))
+        if (!message.includes("WebSocket connection opened")) {
             return;
-        if (helloTimeoutId)
+        }
+        if (helloTimeoutId) {
             clearTimeout(helloTimeoutId);
+        }
         helloTimeoutId = setTimeout(() => {
             if (!gateway?.isConnected) {
                 runtime.log?.(danger(`connection stalled: no HELLO received within ${HELLO_TIMEOUT_MS}ms, forcing reconnect`));
@@ -528,9 +526,11 @@ export async function monitorDiscordProvider(opts = {}) {
         });
     }
     finally {
+        unregisterGateway(account.accountId);
         stopGatewayLogging();
-        if (helloTimeoutId)
+        if (helloTimeoutId) {
             clearTimeout(helloTimeoutId);
+        }
         gatewayEmitter?.removeListener("debug", onGatewayDebug);
         abortSignal?.removeEventListener("abort", onAbort);
         if (execApprovalsHandler) {
@@ -549,3 +549,8 @@ async function clearDiscordNativeCommands(params) {
         params.runtime.error?.(danger(`discord: failed to clear native commands: ${String(err)}`));
     }
 }
+export const __testing = {
+    createDiscordGatewayPlugin,
+    dedupeSkillCommandsForDiscord,
+    resolveDiscordRestFetch,
+};

package/dist/discord/monitor/reply-context.js

@@ -1,27 +1,31 @@
-import { formatAgentEnvelope } from "../../auto-reply/envelope.js";
-import { formatDiscordUserTag, resolveTimestampMs } from "./format.js";
-export function resolveReplyContext(message, resolveDiscordMessageText, options) {
+import { resolveTimestampMs } from "./format.js";
+import { resolveDiscordSenderIdentity } from "./sender-identity.js";
+export function resolveReplyContext(message, resolveDiscordMessageText) {
     const referenced = message.referencedMessage;
-    if (!referenced?.author)
+    if (!referenced?.author) {
         return null;
+    }
     const referencedText = resolveDiscordMessageText(referenced, {
         includeForwarded: true,
     });
-    if (!referencedText)
+    if (!referencedText) {
         return null;
-    const fromLabel = referenced.author ? buildDirectLabel(referenced.author) : "Unknown";
-    const body = `${referencedText}\n[discord message id: ${referenced.id} channel: ${referenced.channelId} from: ${formatDiscordUserTag(referenced.author)} user id:${referenced.author?.id ?? "unknown"}]`;
-    return formatAgentEnvelope({
-        channel: "Discord",
-        from: fromLabel,
-        timestamp: resolveTimestampMs(referenced.timestamp),
-        body,
-        envelope: options?.envelope,
+    }
+    const sender = resolveDiscordSenderIdentity({
+        author: referenced.author,
+        pluralkitInfo: null,
     });
+    return {
+        id: referenced.id,
+        channelId: referenced.channelId,
+        sender: sender.tag ?? sender.label ?? "unknown",
+        body: referencedText,
+        timestamp: resolveTimestampMs(referenced.timestamp),
+    };
 }
-export function buildDirectLabel(author) {
-    const username = formatDiscordUserTag(author);
-    return `${username} user id:${author.id}`;
+export function buildDirectLabel(author, tagOverride) {
+    const username = tagOverride?.trim() || resolveDiscordSenderIdentity({ author, pluralkitInfo: null }).tag;
+    return `${username ?? "unknown"} user id:${author.id}`;
 }
 export function buildGuildLabel(params) {
     const { guild, channelName, channelId } = params;

package/dist/discord/monitor/reply-delivery.js

@@ -1,6 +1,6 @@
 import { convertMarkdownTables } from "../../markdown/tables.js";
 import { chunkDiscordTextWithMode } from "../chunk.js";
-import { sendMessageDiscord } from "../send.js";
+import { sendMessageDiscord, sendVoiceMessageDiscord } from "../send.js";
 export async function deliverDiscordReply(params) {
     const chunkLimit = Math.min(params.textLimit, 2000);
     for (const payload of params.replies) {
@@ -8,36 +8,67 @@ export async function deliverDiscordReply(params) {
         const rawText = payload.text ?? "";
         const tableMode = params.tableMode ?? "code";
         const text = convertMarkdownTables(rawText, tableMode);
-        if (!text && mediaList.length === 0)
+        if (!text && mediaList.length === 0) {
             continue;
+        }
         const replyTo = params.replyToId?.trim() || undefined;
         if (mediaList.length === 0) {
-            let isFirstChunk = true;
             const mode = params.chunkMode ?? "length";
             const chunks = chunkDiscordTextWithMode(text, {
                 maxChars: chunkLimit,
                 maxLines: params.maxLinesPerMessage,
                 chunkMode: mode,
             });
-            if (!chunks.length && text)
+            if (!chunks.length && text) {
                 chunks.push(text);
+            }
             for (const chunk of chunks) {
                 const trimmed = chunk.trim();
-                if (!trimmed)
+                if (!trimmed) {
                     continue;
+                }
                 await sendMessageDiscord(params.target, trimmed, {
                     token: params.token,
                     rest: params.rest,
                     accountId: params.accountId,
-                    replyTo: isFirstChunk ? replyTo : undefined,
+                    replyTo,
                 });
-                isFirstChunk = false;
             }
             continue;
         }
         const firstMedia = mediaList[0];
-        if (!firstMedia)
+        if (!firstMedia) {
             continue;
+        }
+        // Voice message path: audioAsVoice flag routes through sendVoiceMessageDiscord
+        if (payload.audioAsVoice) {
+            await sendVoiceMessageDiscord(params.target, firstMedia, {
+                token: params.token,
+                rest: params.rest,
+                accountId: params.accountId,
+                replyTo,
+            });
+            // Voice messages cannot include text; send remaining text separately if present
+            if (text.trim()) {
+                await sendMessageDiscord(params.target, text, {
+                    token: params.token,
+                    rest: params.rest,
+                    accountId: params.accountId,
+                    replyTo,
+                });
+            }
+            // Additional media items are sent as regular attachments (voice is single-file only)
+            for (const extra of mediaList.slice(1)) {
+                await sendMessageDiscord(params.target, "", {
+                    token: params.token,
+                    rest: params.rest,
+                    mediaUrl: extra,
+                    accountId: params.accountId,
+                    replyTo,
+                });
+            }
+            continue;
+        }
         await sendMessageDiscord(params.target, text, {
             token: params.token,
             rest: params.rest,
@@ -51,6 +82,7 @@ export async function deliverDiscordReply(params) {
                 rest: params.rest,
                 mediaUrl: extra,
                 accountId: params.accountId,
+                replyTo,
             });
         }
     }

package/dist/discord/monitor/rest-fetch.js

@@ -0,0 +1,22 @@
+import { ProxyAgent, fetch as undiciFetch } from "undici";
+import { danger } from "../../globals.js";
+import { wrapFetchWithAbortSignal } from "../../infra/fetch.js";
+export function resolveDiscordRestFetch(proxyUrl, runtime) {
+    const proxy = proxyUrl?.trim();
+    if (!proxy) {
+        return fetch;
+    }
+    try {
+        const agent = new ProxyAgent(proxy);
+        const fetcher = ((input, init) => undiciFetch(input, {
+            ...init,
+            dispatcher: agent,
+        }));
+        runtime.log?.("discord: rest proxy enabled");
+        return wrapFetchWithAbortSignal(fetcher);
+    }
+    catch (err) {
+        runtime.error?.(danger(`discord: invalid rest proxy: ${String(err)}`));
+        return fetch;
+    }
+}