@poolzin/pool-bot 2026.2.24 → 2026.2.26

package/dist/discord/monitor/thread-bindings.state.js

@@ -0,0 +1,358 @@
+import fs from "node:fs";
+import path from "node:path";
+import { resolveStateDir } from "../../config/paths.js";
+import { loadJsonFile, saveJsonFile } from "../../infra/json-file.js";
+import { normalizeAccountId, resolveAgentIdFromSessionKey } from "../../routing/session-key.js";
+import { DEFAULT_THREAD_BINDING_TTL_MS, RECENT_UNBOUND_WEBHOOK_ECHO_TTL_MS, THREAD_BINDINGS_VERSION, } from "./thread-bindings.types.js";
+// Plugin hooks can load this module via Jiti while core imports it via ESM.
+// Store mutable state on globalThis so both loader paths share one registry.
+const THREAD_BINDINGS_STATE_KEY = "__poolbotDiscordThreadBindingsState";
+function createThreadBindingsGlobalState() {
+    return {
+        managersByAccountId: new Map(),
+        bindingsByThreadId: new Map(),
+        bindingsBySessionKey: new Map(),
+        tokensByAccountId: new Map(),
+        recentUnboundWebhookEchoesByBindingKey: new Map(),
+        reusableWebhooksByAccountChannel: new Map(),
+        persistByAccountId: new Map(),
+        loadedBindings: false,
+    };
+}
+function resolveThreadBindingsGlobalState() {
+    const runtimeGlobal = globalThis;
+    if (!runtimeGlobal[THREAD_BINDINGS_STATE_KEY]) {
+        runtimeGlobal[THREAD_BINDINGS_STATE_KEY] = createThreadBindingsGlobalState();
+    }
+    return runtimeGlobal[THREAD_BINDINGS_STATE_KEY];
+}
+const THREAD_BINDINGS_STATE = resolveThreadBindingsGlobalState();
+export const MANAGERS_BY_ACCOUNT_ID = THREAD_BINDINGS_STATE.managersByAccountId;
+export const BINDINGS_BY_THREAD_ID = THREAD_BINDINGS_STATE.bindingsByThreadId;
+export const BINDINGS_BY_SESSION_KEY = THREAD_BINDINGS_STATE.bindingsBySessionKey;
+export const TOKENS_BY_ACCOUNT_ID = THREAD_BINDINGS_STATE.tokensByAccountId;
+export const RECENT_UNBOUND_WEBHOOK_ECHOES_BY_BINDING_KEY = THREAD_BINDINGS_STATE.recentUnboundWebhookEchoesByBindingKey;
+export const REUSABLE_WEBHOOKS_BY_ACCOUNT_CHANNEL = THREAD_BINDINGS_STATE.reusableWebhooksByAccountChannel;
+export const PERSIST_BY_ACCOUNT_ID = THREAD_BINDINGS_STATE.persistByAccountId;
+export function rememberThreadBindingToken(params) {
+    const normalizedAccountId = normalizeAccountId(params.accountId);
+    const token = params.token?.trim();
+    if (!token) {
+        return;
+    }
+    TOKENS_BY_ACCOUNT_ID.set(normalizedAccountId, token);
+}
+export function forgetThreadBindingToken(accountId) {
+    TOKENS_BY_ACCOUNT_ID.delete(normalizeAccountId(accountId));
+}
+export function getThreadBindingToken(accountId) {
+    return TOKENS_BY_ACCOUNT_ID.get(normalizeAccountId(accountId));
+}
+export function shouldDefaultPersist() {
+    return !(process.env.VITEST || process.env.NODE_ENV === "test");
+}
+export function resolveThreadBindingsPath() {
+    return path.join(resolveStateDir(process.env), "discord", "thread-bindings.json");
+}
+export function normalizeTargetKind(raw, targetSessionKey) {
+    if (raw === "subagent" || raw === "acp") {
+        return raw;
+    }
+    return targetSessionKey.includes(":subagent:") ? "subagent" : "acp";
+}
+export function normalizeThreadId(raw) {
+    if (typeof raw === "number" && Number.isFinite(raw)) {
+        return String(Math.floor(raw));
+    }
+    if (typeof raw !== "string") {
+        return undefined;
+    }
+    const trimmed = raw.trim();
+    return trimmed ? trimmed : undefined;
+}
+export function toBindingRecordKey(params) {
+    return `${normalizeAccountId(params.accountId)}:${params.threadId.trim()}`;
+}
+export function resolveBindingRecordKey(params) {
+    const threadId = normalizeThreadId(params.threadId);
+    if (!threadId) {
+        return undefined;
+    }
+    return toBindingRecordKey({
+        accountId: normalizeAccountId(params.accountId),
+        threadId,
+    });
+}
+function normalizePersistedBinding(threadIdKey, raw) {
+    if (!raw || typeof raw !== "object") {
+        return null;
+    }
+    const value = raw;
+    const threadId = normalizeThreadId(value.threadId ?? threadIdKey);
+    const channelId = typeof value.channelId === "string" ? value.channelId.trim() : "";
+    const targetSessionKey = typeof value.targetSessionKey === "string"
+        ? value.targetSessionKey.trim()
+        : typeof value.sessionKey === "string"
+            ? value.sessionKey.trim()
+            : "";
+    if (!threadId || !channelId || !targetSessionKey) {
+        return null;
+    }
+    const accountId = normalizeAccountId(value.accountId);
+    const targetKind = normalizeTargetKind(value.targetKind, targetSessionKey);
+    const agentIdRaw = typeof value.agentId === "string" ? value.agentId.trim() : "";
+    const agentId = agentIdRaw || resolveAgentIdFromSessionKey(targetSessionKey);
+    const label = typeof value.label === "string" ? value.label.trim() || undefined : undefined;
+    const webhookId = typeof value.webhookId === "string" ? value.webhookId.trim() || undefined : undefined;
+    const webhookToken = typeof value.webhookToken === "string" ? value.webhookToken.trim() || undefined : undefined;
+    const boundBy = typeof value.boundBy === "string" ? value.boundBy.trim() || "system" : "system";
+    const boundAt = typeof value.boundAt === "number" && Number.isFinite(value.boundAt)
+        ? Math.floor(value.boundAt)
+        : Date.now();
+    const expiresAt = typeof value.expiresAt === "number" && Number.isFinite(value.expiresAt)
+        ? Math.max(0, Math.floor(value.expiresAt))
+        : undefined;
+    return {
+        accountId,
+        channelId,
+        threadId,
+        targetKind,
+        targetSessionKey,
+        agentId,
+        label,
+        webhookId,
+        webhookToken,
+        boundBy,
+        boundAt,
+        expiresAt,
+    };
+}
+export function normalizeThreadBindingTtlMs(raw) {
+    if (typeof raw !== "number" || !Number.isFinite(raw)) {
+        return DEFAULT_THREAD_BINDING_TTL_MS;
+    }
+    const ttlMs = Math.floor(raw);
+    if (ttlMs < 0) {
+        return DEFAULT_THREAD_BINDING_TTL_MS;
+    }
+    return ttlMs;
+}
+export function resolveThreadBindingExpiresAt(params) {
+    if (typeof params.record.expiresAt === "number" && Number.isFinite(params.record.expiresAt)) {
+        const explicitExpiresAt = Math.floor(params.record.expiresAt);
+        if (explicitExpiresAt <= 0) {
+            // 0 is an explicit per-binding TTL disable sentinel.
+            return undefined;
+        }
+        return explicitExpiresAt;
+    }
+    if (params.sessionTtlMs <= 0) {
+        return undefined;
+    }
+    const boundAt = Math.floor(params.record.boundAt);
+    if (!Number.isFinite(boundAt) || boundAt <= 0) {
+        return undefined;
+    }
+    return boundAt + params.sessionTtlMs;
+}
+function linkSessionBinding(targetSessionKey, bindingKey) {
+    const key = targetSessionKey.trim();
+    if (!key) {
+        return;
+    }
+    const threads = BINDINGS_BY_SESSION_KEY.get(key) ?? new Set();
+    threads.add(bindingKey);
+    BINDINGS_BY_SESSION_KEY.set(key, threads);
+}
+function unlinkSessionBinding(targetSessionKey, bindingKey) {
+    const key = targetSessionKey.trim();
+    if (!key) {
+        return;
+    }
+    const threads = BINDINGS_BY_SESSION_KEY.get(key);
+    if (!threads) {
+        return;
+    }
+    threads.delete(bindingKey);
+    if (threads.size === 0) {
+        BINDINGS_BY_SESSION_KEY.delete(key);
+    }
+}
+export function toReusableWebhookKey(params) {
+    return `${params.accountId.trim().toLowerCase()}:${params.channelId.trim()}`;
+}
+export function rememberReusableWebhook(record) {
+    const webhookId = record.webhookId?.trim();
+    const webhookToken = record.webhookToken?.trim();
+    if (!webhookId || !webhookToken) {
+        return;
+    }
+    const key = toReusableWebhookKey({
+        accountId: record.accountId,
+        channelId: record.channelId,
+    });
+    REUSABLE_WEBHOOKS_BY_ACCOUNT_CHANNEL.set(key, { webhookId, webhookToken });
+}
+export function rememberRecentUnboundWebhookEcho(record) {
+    const webhookId = record.webhookId?.trim();
+    if (!webhookId) {
+        return;
+    }
+    const bindingKey = resolveBindingRecordKey({
+        accountId: record.accountId,
+        threadId: record.threadId,
+    });
+    if (!bindingKey) {
+        return;
+    }
+    RECENT_UNBOUND_WEBHOOK_ECHOES_BY_BINDING_KEY.set(bindingKey, {
+        webhookId,
+        expiresAt: Date.now() + RECENT_UNBOUND_WEBHOOK_ECHO_TTL_MS,
+    });
+}
+function clearRecentUnboundWebhookEcho(bindingKeyRaw) {
+    const key = bindingKeyRaw.trim();
+    if (!key) {
+        return;
+    }
+    RECENT_UNBOUND_WEBHOOK_ECHOES_BY_BINDING_KEY.delete(key);
+}
+export function setBindingRecord(record) {
+    const bindingKey = toBindingRecordKey({
+        accountId: record.accountId,
+        threadId: record.threadId,
+    });
+    const existing = BINDINGS_BY_THREAD_ID.get(bindingKey);
+    if (existing) {
+        unlinkSessionBinding(existing.targetSessionKey, bindingKey);
+    }
+    BINDINGS_BY_THREAD_ID.set(bindingKey, record);
+    linkSessionBinding(record.targetSessionKey, bindingKey);
+    clearRecentUnboundWebhookEcho(bindingKey);
+    rememberReusableWebhook(record);
+}
+export function removeBindingRecord(bindingKeyRaw) {
+    const key = bindingKeyRaw.trim();
+    if (!key) {
+        return null;
+    }
+    const existing = BINDINGS_BY_THREAD_ID.get(key);
+    if (!existing) {
+        return null;
+    }
+    BINDINGS_BY_THREAD_ID.delete(key);
+    unlinkSessionBinding(existing.targetSessionKey, key);
+    return existing;
+}
+export function isRecentlyUnboundThreadWebhookMessage(params) {
+    const webhookId = params.webhookId?.trim() || "";
+    if (!webhookId) {
+        return false;
+    }
+    const bindingKey = resolveBindingRecordKey({
+        accountId: params.accountId,
+        threadId: params.threadId,
+    });
+    if (!bindingKey) {
+        return false;
+    }
+    const suppressed = RECENT_UNBOUND_WEBHOOK_ECHOES_BY_BINDING_KEY.get(bindingKey);
+    if (!suppressed) {
+        return false;
+    }
+    if (suppressed.expiresAt <= Date.now()) {
+        RECENT_UNBOUND_WEBHOOK_ECHOES_BY_BINDING_KEY.delete(bindingKey);
+        return false;
+    }
+    return suppressed.webhookId === webhookId;
+}
+function shouldPersistAnyBindingState() {
+    for (const value of PERSIST_BY_ACCOUNT_ID.values()) {
+        if (value) {
+            return true;
+        }
+    }
+    return false;
+}
+export function shouldPersistBindingMutations() {
+    if (shouldPersistAnyBindingState()) {
+        return true;
+    }
+    return fs.existsSync(resolveThreadBindingsPath());
+}
+export function saveBindingsToDisk(params = {}) {
+    if (!params.force && !shouldPersistAnyBindingState()) {
+        return;
+    }
+    const bindings = {};
+    for (const [bindingKey, record] of BINDINGS_BY_THREAD_ID.entries()) {
+        bindings[bindingKey] = { ...record };
+    }
+    const payload = {
+        version: THREAD_BINDINGS_VERSION,
+        bindings,
+    };
+    saveJsonFile(resolveThreadBindingsPath(), payload);
+}
+export function ensureBindingsLoaded() {
+    if (THREAD_BINDINGS_STATE.loadedBindings) {
+        return;
+    }
+    THREAD_BINDINGS_STATE.loadedBindings = true;
+    BINDINGS_BY_THREAD_ID.clear();
+    BINDINGS_BY_SESSION_KEY.clear();
+    REUSABLE_WEBHOOKS_BY_ACCOUNT_CHANNEL.clear();
+    const raw = loadJsonFile(resolveThreadBindingsPath());
+    if (!raw || typeof raw !== "object") {
+        return;
+    }
+    const payload = raw;
+    if (payload.version !== 1 || !payload.bindings || typeof payload.bindings !== "object") {
+        return;
+    }
+    for (const [threadId, entry] of Object.entries(payload.bindings)) {
+        const normalized = normalizePersistedBinding(threadId, entry);
+        if (!normalized) {
+            continue;
+        }
+        setBindingRecord(normalized);
+    }
+}
+export function resolveBindingIdsForSession(params) {
+    const key = params.targetSessionKey.trim();
+    if (!key) {
+        return [];
+    }
+    const ids = BINDINGS_BY_SESSION_KEY.get(key);
+    if (!ids) {
+        return [];
+    }
+    const out = [];
+    for (const bindingKey of ids.values()) {
+        const record = BINDINGS_BY_THREAD_ID.get(bindingKey);
+        if (!record) {
+            continue;
+        }
+        if (params.accountId && record.accountId !== params.accountId) {
+            continue;
+        }
+        if (params.targetKind && record.targetKind !== params.targetKind) {
+            continue;
+        }
+        out.push(bindingKey);
+    }
+    return out;
+}
+export function resetThreadBindingsForTests() {
+    for (const manager of MANAGERS_BY_ACCOUNT_ID.values()) {
+        manager.stop();
+    }
+    MANAGERS_BY_ACCOUNT_ID.clear();
+    BINDINGS_BY_THREAD_ID.clear();
+    BINDINGS_BY_SESSION_KEY.clear();
+    RECENT_UNBOUND_WEBHOOK_ECHOES_BY_BINDING_KEY.clear();
+    REUSABLE_WEBHOOKS_BY_ACCOUNT_CHANNEL.clear();
+    TOKENS_BY_ACCOUNT_ID.clear();
+    PERSIST_BY_ACCOUNT_ID.clear();
+    THREAD_BINDINGS_STATE.loadedBindings = false;
+}

package/dist/discord/monitor/thread-bindings.types.js

@@ -0,0 +1,6 @@
+export const THREAD_BINDINGS_VERSION = 1;
+export const THREAD_BINDINGS_SWEEP_INTERVAL_MS = 120_000;
+export const DEFAULT_THREAD_BINDING_TTL_MS = 24 * 60 * 60 * 1000; // 24h
+export const DEFAULT_FAREWELL_TEXT = "Session ended. Messages here will no longer be routed.";
+export const DISCORD_UNKNOWN_CHANNEL_ERROR_CODE = 10_003;
+export const RECENT_UNBOUND_WEBHOOK_ECHO_TTL_MS = 30_000;

package/dist/discord/resolve-users.js

@@ -1,34 +1,31 @@
 import { fetchDiscord } from "./api.js";
+import { listGuilds } from "./guilds.js";
 import { normalizeDiscordSlug } from "./monitor/allow-list.js";
 import { normalizeDiscordToken } from "./token.js";
 function parseDiscordUserInput(raw) {
     const trimmed = raw.trim();
-    if (!trimmed)
+    if (!trimmed) {
         return {};
+    }
     const mention = trimmed.match(/^<@!?(\d+)>$/);
-    if (mention)
+    if (mention) {
         return { userId: mention[1] };
+    }
     const prefixed = trimmed.match(/^(?:user:|discord:)?(\d+)$/i);
-    if (prefixed)
+    if (prefixed) {
         return { userId: prefixed[1] };
+    }
     const split = trimmed.includes("/") ? trimmed.split("/") : trimmed.split("#");
     if (split.length >= 2) {
         const guild = split[0]?.trim();
         const user = split.slice(1).join("#").trim();
-        if (guild && /^\d+$/.test(guild))
+        if (guild && /^\d+$/.test(guild)) {
             return { guildId: guild, userName: user };
+        }
         return { guildName: guild, userName: user };
     }
     return { userName: trimmed.replace(/^@/, "") };
 }
-async function listGuilds(token, fetcher) {
-    const raw = await fetchDiscord("/users/@me/guilds", token, fetcher);
-    return raw.map((guild) => ({
-        id: guild.id,
-        name: guild.name,
-        slug: normalizeDiscordSlug(guild.name),
-    }));
-}
 function scoreDiscordMember(member, query) {
     const q = query.toLowerCase();
     const user = member.user;
@@ -36,23 +33,36 @@ function scoreDiscordMember(member, query) {
         .map((value) => value?.toLowerCase())
         .filter(Boolean);
     let score = 0;
-    if (candidates.some((value) => value === q))
+    if (candidates.some((value) => value === q)) {
         score += 3;
-    if (candidates.some((value) => value?.includes(q)))
+    }
+    if (candidates.some((value) => value?.includes(q))) {
         score += 1;
-    if (!user.bot)
+    }
+    if (!user.bot) {
         score += 1;
+    }
     return score;
 }
 export async function resolveDiscordUserAllowlist(params) {
     const token = normalizeDiscordToken(params.token);
-    if (!token)
+    if (!token) {
         return params.entries.map((input) => ({
             input,
             resolved: false,
         }));
+    }
     const fetcher = params.fetcher ?? fetch;
-    const guilds = await listGuilds(token, fetcher);
+    // Lazy-load guilds: only fetch when an entry actually needs username search.
+    // This prevents listGuilds() failures (permissions, network) from blocking
+    // resolution of plain user-id entries that don't need guild data at all.
+    let guilds = null;
+    const getGuilds = async () => {
+        if (!guilds) {
+            guilds = await listGuilds(token, fetcher);
+        }
+        return guilds;
+    };
     const results = [];
     for (const input of params.entries) {
         const parsed = parseDiscordUserInput(input);
@@ -70,11 +80,12 @@ export async function resolveDiscordUserAllowlist(params) {
             continue;
         }
         const guildName = parsed.guildName?.trim();
+        const allGuilds = await getGuilds();
         const guildList = parsed.guildId
-            ? guilds.filter((g) => g.id === parsed.guildId)
+            ? allGuilds.filter((g) => g.id === parsed.guildId)
             : guildName
-                ? guilds.filter((g) => g.slug === normalizeDiscordSlug(guildName))
-                : guilds;
+                ? allGuilds.filter((g) => g.slug === normalizeDiscordSlug(guildName))
+                : allGuilds;
         let best = null;
         let matches = 0;
         for (const guild of guildList) {
@@ -85,8 +96,9 @@ export async function resolveDiscordUserAllowlist(params) {
             const members = await fetchDiscord(`/guilds/${guild.id}/members/search?${paramsObj.toString()}`, token, fetcher);
             for (const member of members) {
                 const score = scoreDiscordMember(member, query);
-                if (score === 0)
+                if (score === 0) {
                     continue;
+                }
                 matches += 1;
                 if (!best || score > best.score) {
                     best = { member, guild, score };

package/dist/discord/send.channels.js

@@ -34,6 +34,21 @@ export async function editChannelDiscord(payload, opts = {}) {
         body.nsfw = payload.nsfw;
     if (payload.rateLimitPerUser !== undefined)
         body.rate_limit_per_user = payload.rateLimitPerUser;
+    if (payload.archived !== undefined)
+        body.archived = payload.archived;
+    if (payload.locked !== undefined)
+        body.locked = payload.locked;
+    if (payload.autoArchiveDuration !== undefined)
+        body.auto_archive_duration = payload.autoArchiveDuration;
+    if (payload.availableTags !== undefined) {
+        body.available_tags = payload.availableTags.map((t) => ({
+            ...(t.id !== undefined && { id: t.id }),
+            name: t.name,
+            ...(t.moderated !== undefined && { moderated: t.moderated }),
+            ...(t.emoji_id !== undefined && { emoji_id: t.emoji_id }),
+            ...(t.emoji_name !== undefined && { emoji_name: t.emoji_name }),
+        }));
+    }
     return (await rest.patch(Routes.channel(payload.channelId), {
         body,
     }));

package/dist/discord/send.js

@@ -2,7 +2,8 @@ export { createChannelDiscord, deleteChannelDiscord, editChannelDiscord, moveCha
 export { listGuildEmojisDiscord, uploadEmojiDiscord, uploadStickerDiscord, } from "./send.emojis-stickers.js";
 export { addRoleDiscord, banMemberDiscord, createScheduledEventDiscord, fetchChannelInfoDiscord, fetchMemberInfoDiscord, fetchRoleInfoDiscord, fetchVoiceStatusDiscord, kickMemberDiscord, listGuildChannelsDiscord, listScheduledEventsDiscord, removeRoleDiscord, timeoutMemberDiscord, } from "./send.guild.js";
 export { createThreadDiscord, deleteMessageDiscord, editMessageDiscord, fetchMessageDiscord, listPinsDiscord, listThreadsDiscord, pinMessageDiscord, readMessagesDiscord, searchMessagesDiscord, unpinMessageDiscord, } from "./send.messages.js";
-export { sendMessageDiscord, sendPollDiscord, sendStickerDiscord, sendVoiceMessageDiscord, } from "./send.outbound.js";
+export { sendMessageDiscord, sendPollDiscord, sendStickerDiscord, sendWebhookMessageDiscord, sendVoiceMessageDiscord, } from "./send.outbound.js";
 export { sendDiscordComponentMessage } from "./send.components.js";
-export { fetchChannelPermissionsDiscord, fetchReactionsDiscord, reactMessageDiscord, removeOwnReactionsDiscord, removeReactionDiscord, } from "./send.reactions.js";
+export { fetchChannelPermissionsDiscord, hasAllGuildPermissionsDiscord, hasAnyGuildPermissionDiscord, fetchMemberGuildPermissionsDiscord, } from "./send.permissions.js";
+export { fetchReactionsDiscord, reactMessageDiscord, removeOwnReactionsDiscord, removeReactionDiscord, } from "./send.reactions.js";
 export { DiscordSendError } from "./send.types.js";

package/dist/discord/send.outbound.js

@@ -29,6 +29,19 @@ function deriveForumThreadName(text) {
 function isForumLikeType(channelType) {
     return channelType === ChannelType.GuildForum || channelType === ChannelType.GuildMedia;
 }
+function toDiscordSendResult(result, fallbackChannelId) {
+    return {
+        messageId: result.id ? String(result.id) : "unknown",
+        channelId: String(result.channel_id ?? fallbackChannelId),
+    };
+}
+async function resolveDiscordSendTarget(to, opts) {
+    const cfg = loadConfig();
+    const { rest, request } = createDiscordClient(opts, cfg);
+    const recipient = await parseAndResolveRecipient(to, opts.accountId);
+    const { channelId } = await resolveChannelId(rest, recipient, request);
+    return { rest, request, channelId };
+}
 export async function sendMessageDiscord(to, text, opts = {}) {
     const cfg = loadConfig();
     const accountInfo = resolveDiscordAccount({
@@ -122,10 +135,10 @@ export async function sendMessageDiscord(to, text, opts = {}) {
             accountId: accountInfo.accountId,
             direction: "outbound",
         });
-        return {
-            messageId: messageId ? String(messageId) : "unknown",
-            channelId: String(resultChannelId ?? channelId),
-        };
+        return toDiscordSendResult({
+            id: messageId,
+            channel_id: resultChannelId,
+        }, channelId);
     }
     let result;
     try {
@@ -149,16 +162,71 @@ export async function sendMessageDiscord(to, text, opts = {}) {
         accountId: accountInfo.accountId,
         direction: "outbound",
     });
+    return toDiscordSendResult(result, channelId);
+}
+function resolveWebhookExecutionUrl(params) {
+    const baseUrl = new URL(`https://discord.com/api/v10/webhooks/${encodeURIComponent(params.webhookId)}/${encodeURIComponent(params.webhookToken)}`);
+    baseUrl.searchParams.set("wait", params.wait === false ? "false" : "true");
+    if (params.threadId !== undefined && params.threadId !== null && params.threadId !== "") {
+        baseUrl.searchParams.set("thread_id", String(params.threadId));
+    }
+    return baseUrl.toString();
+}
+export async function sendWebhookMessageDiscord(text, opts) {
+    const webhookId = opts.webhookId.trim();
+    const webhookToken = opts.webhookToken.trim();
+    if (!webhookId || !webhookToken) {
+        throw new Error("Discord webhook id/token are required");
+    }
+    const replyTo = typeof opts.replyTo === "string" ? opts.replyTo.trim() : "";
+    const messageReference = replyTo ? { message_id: replyTo, fail_if_not_exists: false } : undefined;
+    const response = await fetch(resolveWebhookExecutionUrl({
+        webhookId,
+        webhookToken,
+        threadId: opts.threadId,
+        wait: opts.wait,
+    }), {
+        method: "POST",
+        headers: {
+            "content-type": "application/json",
+        },
+        body: JSON.stringify({
+            content: text,
+            username: opts.username?.trim() || undefined,
+            avatar_url: opts.avatarUrl?.trim() || undefined,
+            ...(messageReference ? { message_reference: messageReference } : {}),
+        }),
+    });
+    if (!response.ok) {
+        const raw = await response.text().catch(() => "");
+        throw new Error(`Discord webhook send failed (${response.status}${raw ? `: ${raw.slice(0, 200)}` : ""})`);
+    }
+    const payload = (await response.json().catch(() => ({})));
+    try {
+        const account = resolveDiscordAccount({
+            cfg: loadConfig(),
+            accountId: opts.accountId,
+        });
+        recordChannelActivity({
+            channel: "discord",
+            accountId: account.accountId,
+            direction: "outbound",
+        });
+    }
+    catch {
+        // Best-effort telemetry only.
+    }
     return {
-        messageId: result.id ? String(result.id) : "unknown",
-        channelId: String(result.channel_id ?? channelId),
+        messageId: payload.id ? String(payload.id) : "unknown",
+        channelId: payload.channel_id
+            ? String(payload.channel_id)
+            : opts.threadId
+                ? String(opts.threadId)
+                : "",
     };
 }
 export async function sendStickerDiscord(to, stickerIds, opts = {}) {
-    const cfg = loadConfig();
-    const { rest, request } = createDiscordClient(opts, cfg);
-    const recipient = await parseAndResolveRecipient(to, opts.accountId);
-    const { channelId } = await resolveChannelId(rest, recipient, request);
+    const { rest, request, channelId } = await resolveDiscordSendTarget(to, opts);
     const content = opts.content?.trim();
     const stickers = normalizeStickerIds(stickerIds);
     const res = (await request(() => rest.post(Routes.channelMessages(channelId), {
@@ -167,16 +235,10 @@ export async function sendStickerDiscord(to, stickerIds, opts = {}) {
             sticker_ids: stickers,
         },
     }), "sticker"));
-    return {
-        messageId: res.id ? String(res.id) : "unknown",
-        channelId: String(res.channel_id ?? channelId),
-    };
+    return toDiscordSendResult(res, channelId);
 }
 export async function sendPollDiscord(to, poll, opts = {}) {
-    const cfg = loadConfig();
-    const { rest, request } = createDiscordClient(opts, cfg);
-    const recipient = await parseAndResolveRecipient(to, opts.accountId);
-    const { channelId } = await resolveChannelId(rest, recipient, request);
+    const { rest, request, channelId } = await resolveDiscordSendTarget(to, opts);
     const content = opts.content?.trim();
     if (poll.durationSeconds !== undefined) {
         throw new Error("Discord polls do not support durationSeconds; use durationHours");
@@ -190,10 +252,7 @@ export async function sendPollDiscord(to, poll, opts = {}) {
             ...(flags ? { flags } : {}),
         },
     }), "poll"));
-    return {
-        messageId: res.id ? String(res.id) : "unknown",
-        channelId: String(res.channel_id ?? channelId),
-    };
+    return toDiscordSendResult(res, channelId);
 }
 async function materializeVoiceMessageInput(mediaUrl) {
     // Security: reuse the standard media loader so we apply SSRF guards + allowed-local-root checks.
@@ -251,10 +310,7 @@ export async function sendVoiceMessageDiscord(to, audioPath, opts = {}) {
             accountId: accountInfo.accountId,
             direction: "outbound",
         });
-        return {
-            messageId: result.id ? String(result.id) : "unknown",
-            channelId: String(result.channel_id ?? channelId),
-        };
+        return toDiscordSendResult(result, channelId);
     }
     catch (err) {
         if (channelId && rest && token) {