@poolzin/pool-bot 2026.2.25 → 2026.2.26

package/dist/channels/model-overrides.js

@@ -0,0 +1,82 @@
+import { parseAgentSessionKey } from "../sessions/session-key-utils.js";
+import { normalizeMessageChannel } from "../utils/message-channel.js";
+import { buildChannelKeyCandidates, normalizeChannelSlug, resolveChannelEntryMatchWithFallback, } from "./channel-config.js";
+const THREAD_SUFFIX_REGEX = /:(?:thread|topic):[^:]+$/i;
+function resolveProviderEntry(modelByChannel, channel) {
+    const normalized = normalizeMessageChannel(channel) ?? channel.trim().toLowerCase();
+    return (modelByChannel?.[normalized] ??
+        modelByChannel?.[Object.keys(modelByChannel ?? {}).find((key) => {
+            const normalizedKey = normalizeMessageChannel(key) ?? key.trim().toLowerCase();
+            return normalizedKey === normalized;
+        }) ?? ""]);
+}
+function resolveParentGroupId(groupId) {
+    const raw = groupId?.trim();
+    if (!raw || !THREAD_SUFFIX_REGEX.test(raw)) {
+        return undefined;
+    }
+    const parent = raw.replace(THREAD_SUFFIX_REGEX, "").trim();
+    return parent && parent !== raw ? parent : undefined;
+}
+function resolveGroupIdFromSessionKey(sessionKey) {
+    const raw = sessionKey?.trim();
+    if (!raw) {
+        return undefined;
+    }
+    const parsed = parseAgentSessionKey(raw);
+    const candidate = parsed?.rest ?? raw;
+    const match = candidate.match(/(?:^|:)(?:group|channel):([^:]+)(?::|$)/i);
+    const id = match?.[1]?.trim();
+    return id || undefined;
+}
+function buildChannelCandidates(params) {
+    const groupId = params.groupId?.trim();
+    const parentGroupId = resolveParentGroupId(groupId);
+    const parentGroupIdFromSession = resolveGroupIdFromSessionKey(params.parentSessionKey);
+    const parentGroupIdResolved = resolveParentGroupId(parentGroupIdFromSession) ?? parentGroupIdFromSession;
+    const groupChannel = params.groupChannel?.trim();
+    const groupSubject = params.groupSubject?.trim();
+    const channelBare = groupChannel ? groupChannel.replace(/^#/, "") : undefined;
+    const subjectBare = groupSubject ? groupSubject.replace(/^#/, "") : undefined;
+    const channelSlug = channelBare ? normalizeChannelSlug(channelBare) : undefined;
+    const subjectSlug = subjectBare ? normalizeChannelSlug(subjectBare) : undefined;
+    return buildChannelKeyCandidates(groupId, parentGroupId, parentGroupIdResolved, groupChannel, channelBare, channelSlug, groupSubject, subjectBare, subjectSlug);
+}
+export function resolveChannelModelOverride(params) {
+    const channel = params.channel?.trim();
+    if (!channel) {
+        return null;
+    }
+    const modelByChannel = params.cfg.channels?.modelByChannel;
+    if (!modelByChannel) {
+        return null;
+    }
+    const providerEntries = resolveProviderEntry(modelByChannel, channel);
+    if (!providerEntries) {
+        return null;
+    }
+    const candidates = buildChannelCandidates(params);
+    if (candidates.length === 0) {
+        return null;
+    }
+    const match = resolveChannelEntryMatchWithFallback({
+        entries: providerEntries,
+        keys: candidates,
+        wildcardKey: "*",
+        normalizeKey: (value) => value.trim().toLowerCase(),
+    });
+    const raw = match.entry ?? match.wildcardEntry;
+    if (typeof raw !== "string") {
+        return null;
+    }
+    const model = raw.trim();
+    if (!model) {
+        return null;
+    }
+    return {
+        channel: normalizeMessageChannel(channel) ?? channel.trim().toLowerCase(),
+        model,
+        matchKey: match.matchKey,
+        matchSource: match.matchSource,
+    };
+}

package/dist/channels/plugins/normalize/imessage.js

@@ -4,18 +4,21 @@ const SERVICE_PREFIXES = ["imessage:", "sms:", "auto:"];
 const CHAT_TARGET_PREFIX_RE = /^(chat_id:|chatid:|chat:|chat_guid:|chatguid:|guid:|chat_identifier:|chatidentifier:|chatident:)/i;
 export function normalizeIMessageMessagingTarget(raw) {
     const trimmed = raw.trim();
-    if (!trimmed)
+    if (!trimmed) {
         return undefined;
+    }
     // Preserve service prefix if present (e.g., "sms:+1555" → "sms:+15551234567")
     const lower = trimmed.toLowerCase();
     for (const prefix of SERVICE_PREFIXES) {
         if (lower.startsWith(prefix)) {
             const remainder = trimmed.slice(prefix.length).trim();
             const normalizedHandle = normalizeIMessageHandle(remainder);
-            if (!normalizedHandle)
+            if (!normalizedHandle) {
                 return undefined;
-            if (CHAT_TARGET_PREFIX_RE.test(normalizedHandle))
+            }
+            if (CHAT_TARGET_PREFIX_RE.test(normalizedHandle)) {
                 return normalizedHandle;
+            }
             return `${prefix}${normalizedHandle}`;
         }
     }
@@ -24,13 +27,17 @@ export function normalizeIMessageMessagingTarget(raw) {
 }
 export function looksLikeIMessageTargetId(raw) {
     const trimmed = raw.trim();
-    if (!trimmed)
+    if (!trimmed) {
         return false;
-    if (/^(imessage:|sms:|auto:)/i.test(trimmed))
+    }
+    if (/^(imessage:|sms:|auto:)/i.test(trimmed)) {
         return true;
-    if (CHAT_TARGET_PREFIX_RE.test(trimmed))
+    }
+    if (CHAT_TARGET_PREFIX_RE.test(trimmed)) {
         return true;
-    if (trimmed.includes("@"))
+    }
+    if (trimmed.includes("@")) {
         return true;
+    }
     return /^\+?\d{3,}$/.test(trimmed);
 }

package/dist/channels/plugins/normalize/slack.js

@@ -5,15 +5,20 @@ export function normalizeSlackMessagingTarget(raw) {
 }
 export function looksLikeSlackTargetId(raw) {
     const trimmed = raw.trim();
-    if (!trimmed)
+    if (!trimmed) {
         return false;
-    if (/^<@([A-Z0-9]+)>$/i.test(trimmed))
+    }
+    if (/^<@([A-Z0-9]+)>$/i.test(trimmed)) {
         return true;
-    if (/^(user|channel):/i.test(trimmed))
+    }
+    if (/^(user|channel):/i.test(trimmed)) {
         return true;
-    if (/^slack:/i.test(trimmed))
+    }
+    if (/^slack:/i.test(trimmed)) {
         return true;
-    if (/^[@#]/.test(trimmed))
+    }
+    if (/^[@#]/.test(trimmed)) {
         return true;
+    }
     return /^[CUWGD][A-Z0-9]{8,}$/i.test(trimmed);
 }

package/dist/channels/plugins/normalize/telegram.js

@@ -1,7 +1,8 @@
 export function normalizeTelegramMessagingTarget(raw) {
     const trimmed = raw.trim();
-    if (!trimmed)
+    if (!trimmed) {
         return undefined;
+    }
     let normalized = trimmed;
     if (normalized.startsWith("telegram:")) {
         normalized = normalized.slice("telegram:".length).trim();
@@ -9,23 +10,29 @@ export function normalizeTelegramMessagingTarget(raw) {
     else if (normalized.startsWith("tg:")) {
         normalized = normalized.slice("tg:".length).trim();
     }
-    if (!normalized)
+    if (!normalized) {
         return undefined;
+    }
     const tmeMatch = /^https?:\/\/t\.me\/([A-Za-z0-9_]+)$/i.exec(normalized) ??
         /^t\.me\/([A-Za-z0-9_]+)$/i.exec(normalized);
-    if (tmeMatch?.[1])
+    if (tmeMatch?.[1]) {
         normalized = `@${tmeMatch[1]}`;
-    if (!normalized)
+    }
+    if (!normalized) {
         return undefined;
+    }
     return `telegram:${normalized}`.toLowerCase();
 }
 export function looksLikeTelegramTargetId(raw) {
     const trimmed = raw.trim();
-    if (!trimmed)
+    if (!trimmed) {
         return false;
-    if (/^(telegram|tg):/i.test(trimmed))
+    }
+    if (/^(telegram|tg):/i.test(trimmed)) {
         return true;
-    if (trimmed.startsWith("@"))
+    }
+    if (trimmed.startsWith("@")) {
         return true;
+    }
     return /^-?\d{6,}$/.test(trimmed);
 }

package/dist/channels/plugins/outbound/discord.js

@@ -1,29 +1,101 @@
-import { sendMessageDiscord, sendPollDiscord } from "../../../discord/send.js";
+import { getThreadBindingManager, } from "../../../discord/monitor/thread-bindings.js";
+import { sendMessageDiscord, sendPollDiscord, sendWebhookMessageDiscord, } from "../../../discord/send.js";
+import { normalizeDiscordOutboundTarget } from "../normalize/discord.js";
+function resolveDiscordOutboundTarget(params) {
+    if (params.threadId == null) {
+        return params.to;
+    }
+    const threadId = String(params.threadId).trim();
+    if (!threadId) {
+        return params.to;
+    }
+    return `channel:${threadId}`;
+}
+function resolveDiscordWebhookIdentity(params) {
+    const usernameRaw = params.identity?.name?.trim();
+    const fallbackUsername = params.binding.label?.trim() || params.binding.agentId;
+    const username = (usernameRaw || fallbackUsername || "").slice(0, 80) || undefined;
+    const avatarUrl = params.identity?.avatarUrl?.trim() || undefined;
+    return { username, avatarUrl };
+}
+async function maybeSendDiscordWebhookText(params) {
+    if (params.threadId == null) {
+        return null;
+    }
+    const threadId = String(params.threadId).trim();
+    if (!threadId) {
+        return null;
+    }
+    const manager = getThreadBindingManager(params.accountId ?? undefined);
+    if (!manager) {
+        return null;
+    }
+    const binding = manager.getByThreadId(threadId);
+    if (!binding?.webhookId || !binding?.webhookToken) {
+        return null;
+    }
+    const persona = resolveDiscordWebhookIdentity({
+        identity: params.identity,
+        binding,
+    });
+    const result = await sendWebhookMessageDiscord(params.text, {
+        webhookId: binding.webhookId,
+        webhookToken: binding.webhookToken,
+        accountId: binding.accountId,
+        threadId: binding.threadId,
+        replyTo: params.replyToId ?? undefined,
+        username: persona.username,
+        avatarUrl: persona.avatarUrl,
+    });
+    return result;
+}
 export const discordOutbound = {
     deliveryMode: "direct",
     chunker: null,
     textChunkLimit: 2000,
     pollMaxOptions: 10,
-    sendText: async ({ to, text, accountId, deps, replyToId }) => {
+    resolveTarget: ({ to }) => normalizeDiscordOutboundTarget(to),
+    sendText: async ({ to, text, accountId, deps, replyToId, threadId, identity, silent }) => {
+        if (!silent) {
+            const webhookResult = await maybeSendDiscordWebhookText({
+                text,
+                threadId,
+                accountId,
+                identity,
+                replyToId,
+            }).catch(() => null);
+            if (webhookResult) {
+                return { channel: "discord", ...webhookResult };
+            }
+        }
         const send = deps?.sendDiscord ?? sendMessageDiscord;
-        const result = await send(to, text, {
+        const target = resolveDiscordOutboundTarget({ to, threadId });
+        const result = await send(target, text, {
             verbose: false,
             replyTo: replyToId ?? undefined,
             accountId: accountId ?? undefined,
+            silent: silent ?? undefined,
         });
         return { channel: "discord", ...result };
     },
-    sendMedia: async ({ to, text, mediaUrl, accountId, deps, replyToId }) => {
+    sendMedia: async ({ to, text, mediaUrl, mediaLocalRoots, accountId, deps, replyToId, threadId, silent, }) => {
         const send = deps?.sendDiscord ?? sendMessageDiscord;
-        const result = await send(to, text, {
+        const target = resolveDiscordOutboundTarget({ to, threadId });
+        const result = await send(target, text, {
             verbose: false,
             mediaUrl,
+            mediaLocalRoots,
             replyTo: replyToId ?? undefined,
             accountId: accountId ?? undefined,
+            silent: silent ?? undefined,
         });
         return { channel: "discord", ...result };
     },
-    sendPoll: async ({ to, poll, accountId }) => await sendPollDiscord(to, poll, {
-        accountId: accountId ?? undefined,
-    }),
+    sendPoll: async ({ to, poll, accountId, threadId, silent }) => {
+        const target = resolveDiscordOutboundTarget({ to, threadId });
+        return await sendPollDiscord(target, poll, {
+            accountId: accountId ?? undefined,
+            silent: silent ?? undefined,
+        });
+    },
 };

package/dist/channels/plugins/outbound/signal.js

@@ -1,6 +1,13 @@
 import { chunkText } from "../../../auto-reply/chunk.js";
 import { sendMessageSignal } from "../../../signal/send.js";
 import { resolveChannelMediaMaxBytes } from "../media-limits.js";
+function resolveSignalMaxBytes(params) {
+    return resolveChannelMediaMaxBytes({
+        cfg: params.cfg,
+        resolveChannelLimitMb: ({ cfg, accountId }) => cfg.channels?.signal?.accounts?.[accountId]?.mediaMaxMb ?? cfg.channels?.signal?.mediaMaxMb,
+        accountId: params.accountId,
+    });
+}
 export const signalOutbound = {
     deliveryMode: "direct",
     chunker: chunkText,
@@ -8,28 +15,21 @@ export const signalOutbound = {
     textChunkLimit: 4000,
     sendText: async ({ cfg, to, text, accountId, deps }) => {
         const send = deps?.sendSignal ?? sendMessageSignal;
-        const maxBytes = resolveChannelMediaMaxBytes({
-            cfg,
-            resolveChannelLimitMb: ({ cfg, accountId }) => cfg.channels?.signal?.accounts?.[accountId]?.mediaMaxMb ?? cfg.channels?.signal?.mediaMaxMb,
-            accountId,
-        });
+        const maxBytes = resolveSignalMaxBytes({ cfg, accountId });
         const result = await send(to, text, {
             maxBytes,
             accountId: accountId ?? undefined,
         });
         return { channel: "signal", ...result };
     },
-    sendMedia: async ({ cfg, to, text, mediaUrl, accountId, deps }) => {
+    sendMedia: async ({ cfg, to, text, mediaUrl, mediaLocalRoots, accountId, deps }) => {
         const send = deps?.sendSignal ?? sendMessageSignal;
-        const maxBytes = resolveChannelMediaMaxBytes({
-            cfg,
-            resolveChannelLimitMb: ({ cfg, accountId }) => cfg.channels?.signal?.accounts?.[accountId]?.mediaMaxMb ?? cfg.channels?.signal?.mediaMaxMb,
-            accountId,
-        });
+        const maxBytes = resolveSignalMaxBytes({ cfg, accountId });
         const result = await send(to, text, {
             mediaUrl,
             maxBytes,
             accountId: accountId ?? undefined,
+            mediaLocalRoots,
         });
         return { channel: "signal", ...result };
     },

package/dist/channels/plugins/setup-helpers.js

@@ -5,16 +5,19 @@ function channelHasAccounts(cfg, channelKey) {
     return Boolean(base?.accounts && Object.keys(base.accounts).length > 0);
 }
 function shouldStoreNameInAccounts(params) {
-    if (params.alwaysUseAccounts)
+    if (params.alwaysUseAccounts) {
         return true;
-    if (params.accountId !== DEFAULT_ACCOUNT_ID)
+    }
+    if (params.accountId !== DEFAULT_ACCOUNT_ID) {
         return true;
+    }
     return channelHasAccounts(params.cfg, params.channelKey);
 }
 export function applyAccountNameToChannelSection(params) {
     const trimmed = params.name?.trim();
-    if (!trimmed)
+    if (!trimmed) {
         return params.cfg;
+    }
     const accountId = normalizeAccountId(params.accountId);
     const channels = params.cfg.channels;
     const baseConfig = channels?.[params.channelKey];
@@ -61,13 +64,15 @@ export function applyAccountNameToChannelSection(params) {
     };
 }
 export function migrateBaseNameToDefaultAccount(params) {
-    if (params.alwaysUseAccounts)
+    if (params.alwaysUseAccounts) {
         return params.cfg;
+    }
     const channels = params.cfg.channels;
     const base = channels?.[params.channelKey];
     const baseName = base?.name?.trim();
-    if (!baseName)
+    if (!baseName) {
         return params.cfg;
+    }
     const accounts = {
         ...base?.accounts,
     };

package/dist/channels/sender-label.js

@@ -10,8 +10,9 @@ export function resolveSenderLabel(params) {
     const id = normalize(params.id);
     const display = name ?? username ?? tag ?? "";
     const idPart = e164 ?? id ?? "";
-    if (display && idPart && display !== idPart)
+    if (display && idPart && display !== idPart) {
         return `${display} (${idPart})`;
+    }
     return display || idPart || null;
 }
 export function listSenderLabelCandidates(params) {
@@ -21,18 +22,24 @@ export function listSenderLabelCandidates(params) {
     const tag = normalize(params.tag);
     const e164 = normalize(params.e164);
     const id = normalize(params.id);
-    if (name)
+    if (name) {
         candidates.add(name);
-    if (username)
+    }
+    if (username) {
         candidates.add(username);
-    if (tag)
+    }
+    if (tag) {
         candidates.add(tag);
-    if (e164)
+    }
+    if (e164) {
         candidates.add(e164);
-    if (id)
+    }
+    if (id) {
         candidates.add(id);
+    }
     const resolved = resolveSenderLabel(params);
-    if (resolved)
+    if (resolved) {
         candidates.add(resolved);
+    }
     return Array.from(candidates);
 }

package/dist/channels/session.js

@@ -9,8 +9,9 @@ export async function recordInboundSession(params) {
         createIfMissing,
     }).catch(params.onRecordError);
     const update = params.updateLastRoute;
-    if (!update)
+    if (!update) {
         return;
+    }
     await updateLastRoute({
         storePath,
         sessionKey: update.sessionKey,
@@ -20,7 +21,8 @@ export async function recordInboundSession(params) {
             accountId: update.accountId,
             threadId: update.threadId,
         },
-        ctx,
+        // Avoid leaking inbound origin metadata into a different target session.
+        ctx: update.sessionKey === sessionKey ? ctx : undefined,
         groupResolution,
     });
 }