@poolzin/pool-bot 2026.2.21 → 2026.2.22

package/dist/channels/allowlists/resolve-utils.js

@@ -3,11 +3,13 @@ export function mergeAllowlist(params) {
     const merged = [];
     const push = (value) => {
         const normalized = value.trim();
-        if (!normalized)
+        if (!normalized) {
             return;
+        }
         const key = normalized.toLowerCase();
-        if (seen.has(key))
+        if (seen.has(key)) {
             return;
+        }
         seen.add(key);
         merged.push(normalized);
     };
@@ -19,6 +21,67 @@ export function mergeAllowlist(params) {
     }
     return merged;
 }
+export function buildAllowlistResolutionSummary(resolvedUsers, opts) {
+    const resolvedMap = new Map(resolvedUsers.map((entry) => [entry.input, entry]));
+    const resolvedOk = (entry) => Boolean(entry.resolved && entry.id);
+    const formatResolved = opts?.formatResolved ?? ((entry) => `${entry.input}→${entry.id}`);
+    const mapping = resolvedUsers.filter(resolvedOk).map(formatResolved);
+    const additions = resolvedUsers
+        .filter(resolvedOk)
+        .map((entry) => entry.id)
+        .filter((entry) => Boolean(entry));
+    const unresolved = resolvedUsers
+        .filter((entry) => !resolvedOk(entry))
+        .map((entry) => entry.input);
+    return { resolvedMap, mapping, unresolved, additions };
+}
+export function resolveAllowlistIdAdditions(params) {
+    const additions = [];
+    for (const entry of params.existing) {
+        const trimmed = String(entry).trim();
+        const resolved = params.resolvedMap.get(trimmed);
+        if (resolved?.resolved && resolved.id) {
+            additions.push(resolved.id);
+        }
+    }
+    return additions;
+}
+export function patchAllowlistUsersInConfigEntries(params) {
+    const nextEntries = { ...params.entries };
+    for (const [entryKey, entryConfig] of Object.entries(params.entries)) {
+        if (!entryConfig || typeof entryConfig !== "object") {
+            continue;
+        }
+        const users = entryConfig.users;
+        if (!Array.isArray(users) || users.length === 0) {
+            continue;
+        }
+        const additions = resolveAllowlistIdAdditions({
+            existing: users,
+            resolvedMap: params.resolvedMap,
+        });
+        nextEntries[entryKey] = {
+            ...entryConfig,
+            users: mergeAllowlist({ existing: users, additions }),
+        };
+    }
+    return nextEntries;
+}
+export function addAllowlistUserEntriesFromConfigEntry(target, entry) {
+    if (!entry || typeof entry !== "object") {
+        return;
+    }
+    const users = entry.users;
+    if (!Array.isArray(users)) {
+        return;
+    }
+    for (const value of users) {
+        const trimmed = String(value).trim();
+        if (trimmed && trimmed !== "*") {
+            target.add(trimmed);
+        }
+    }
+}
 export function summarizeMapping(label, mapping, unresolved, runtime) {
     const lines = [];
     if (mapping.length > 0) {

package/dist/channels/chat-type.js

@@ -1,12 +1,16 @@
 export function normalizeChatType(raw) {
     const value = raw?.trim().toLowerCase();
-    if (!value)
+    if (!value) {
         return undefined;
-    if (value === "direct" || value === "dm")
+    }
+    if (value === "direct" || value === "dm") {
         return "direct";
-    if (value === "group")
+    }
+    if (value === "group") {
         return "group";
-    if (value === "channel")
+    }
+    if (value === "channel") {
         return "channel";
+    }
     return undefined;
 }

package/dist/channels/dock.js

@@ -1,21 +1,55 @@
+import { resolveChannelGroupRequireMention, resolveChannelGroupToolsPolicy, } from "../config/group-policy.js";
 import { resolveDiscordAccount } from "../discord/accounts.js";
 import { resolveIMessageAccount } from "../imessage/accounts.js";
+import { requireActivePluginRegistry } from "../plugins/runtime.js";
+import { normalizeAccountId } from "../routing/session-key.js";
 import { resolveSignalAccount } from "../signal/accounts.js";
 import { resolveSlackAccount, resolveSlackReplyToMode } from "../slack/accounts.js";
 import { buildSlackThreadingToolContext } from "../slack/threading-tool-context.js";
 import { resolveTelegramAccount } from "../telegram/accounts.js";
-import { normalizeAccountId } from "../routing/session-key.js";
-import { normalizeE164 } from "../utils.js";
+import { escapeRegExp, normalizeE164 } from "../utils.js";
 import { resolveWhatsAppAccount } from "../web/accounts.js";
 import { normalizeWhatsAppTarget } from "../whatsapp/normalize.js";
-import { requireActivePluginRegistry } from "../plugins/runtime.js";
 import { resolveDiscordGroupRequireMention, resolveDiscordGroupToolPolicy, resolveGoogleChatGroupRequireMention, resolveGoogleChatGroupToolPolicy, resolveIMessageGroupRequireMention, resolveIMessageGroupToolPolicy, resolveSlackGroupRequireMention, resolveSlackGroupToolPolicy, resolveTelegramGroupRequireMention, resolveTelegramGroupToolPolicy, resolveWhatsAppGroupRequireMention, resolveWhatsAppGroupToolPolicy, } from "./plugins/group-mentions.js";
+import { normalizeSignalMessagingTarget } from "./plugins/normalize/signal.js";
 import { CHAT_CHANNEL_ORDER, getChatChannelMeta } from "./registry.js";
 const formatLower = (allowFrom) => allowFrom
     .map((entry) => String(entry).trim())
     .filter(Boolean)
     .map((entry) => entry.toLowerCase());
-const escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+const formatDiscordAllowFrom = (allowFrom) => allowFrom
+    .map((entry) => String(entry)
+    .trim()
+    .replace(/^<@!?/, "")
+    .replace(/>$/, "")
+    .replace(/^discord:/i, "")
+    .replace(/^user:/i, "")
+    .replace(/^pk:/i, "")
+    .trim()
+    .toLowerCase())
+    .filter(Boolean);
+function resolveDirectOrGroupChannelId(context) {
+    const isDirect = context.ChatType?.toLowerCase() === "direct";
+    return (isDirect ? (context.From ?? context.To) : context.To)?.trim() || undefined;
+}
+function buildSignalThreadToolContext(params) {
+    const currentChannelIdRaw = resolveDirectOrGroupChannelId(params.context);
+    const currentChannelId = currentChannelIdRaw
+        ? (normalizeSignalMessagingTarget(currentChannelIdRaw) ?? currentChannelIdRaw.trim())
+        : undefined;
+    return {
+        currentChannelId,
+        currentThreadTs: params.context.ReplyToId,
+        hasRepliedRef: params.hasRepliedRef,
+    };
+}
+function buildIMessageThreadToolContext(params) {
+    return {
+        currentChannelId: resolveDirectOrGroupChannelId(params.context),
+        currentThreadTs: params.context.ReplyToId,
+        hasRepliedRef: params.hasRepliedRef,
+    };
+}
 // Channel docks: lightweight channel metadata/behavior for shared code paths.
 //
 // Rules:
@@ -48,7 +82,7 @@ const DOCKS = {
             resolveToolPolicy: resolveTelegramGroupToolPolicy,
         },
         threading: {
-            resolveReplyToMode: ({ cfg }) => cfg.channels?.telegram?.replyToMode ?? "first",
+            resolveReplyToMode: ({ cfg }) => cfg.channels?.telegram?.replyToMode ?? "off",
             buildToolContext: ({ context, hasRepliedRef }) => {
                 const threadId = context.MessageThreadId ?? context.ReplyToId;
                 return {
@@ -83,13 +117,14 @@ const DOCKS = {
         groups: {
             resolveRequireMention: resolveWhatsAppGroupRequireMention,
             resolveToolPolicy: resolveWhatsAppGroupToolPolicy,
-            resolveGroupIntroHint: () => "WhatsApp IDs: SenderId is the participant JID; [message_id: ...] is the message id for reactions (use SenderId as participant).",
+            resolveGroupIntroHint: () => "WhatsApp IDs: SenderId is the participant JID (group participant id).",
         },
         mentions: {
             stripPatterns: ({ ctx }) => {
                 const selfE164 = (ctx.To ?? "").replace(/^whatsapp:/, "");
-                if (!selfE164)
+                if (!selfE164) {
                     return [];
+                }
                 const escaped = escapeRegExp(selfE164);
                 return [escaped, `@${escaped}`];
             },
@@ -120,11 +155,14 @@ const DOCKS = {
             blockStreamingCoalesceDefaults: { minChars: 1500, idleMs: 1000 },
         },
         elevated: {
-            allowFromFallback: ({ cfg }) => cfg.channels?.discord?.dm?.allowFrom,
+            allowFromFallback: ({ cfg }) => cfg.channels?.discord?.allowFrom ?? cfg.channels?.discord?.dm?.allowFrom,
         },
         config: {
-            resolveAllowFrom: ({ cfg, accountId }) => (resolveDiscordAccount({ cfg, accountId }).config.dm?.allowFrom ?? []).map((entry) => String(entry)),
-            formatAllowFrom: ({ allowFrom }) => formatLower(allowFrom),
+            resolveAllowFrom: ({ cfg, accountId }) => {
+                const account = resolveDiscordAccount({ cfg, accountId });
+                return (account.config.allowFrom ?? account.config.dm?.allowFrom ?? []).map((entry) => String(entry));
+            },
+            formatAllowFrom: ({ allowFrom }) => formatDiscordAllowFrom(allowFrom),
         },
         groups: {
             resolveRequireMention: resolveDiscordGroupRequireMention,
@@ -142,6 +180,65 @@ const DOCKS = {
             }),
         },
     },
+    irc: {
+        id: "irc",
+        capabilities: {
+            chatTypes: ["direct", "group"],
+            media: true,
+            blockStreaming: true,
+        },
+        outbound: { textChunkLimit: 350 },
+        streaming: {
+            blockStreamingCoalesceDefaults: { minChars: 300, idleMs: 1000 },
+        },
+        config: {
+            resolveAllowFrom: ({ cfg, accountId }) => {
+                const channel = cfg.channels?.irc;
+                const normalized = normalizeAccountId(accountId);
+                const account = channel?.accounts?.[normalized] ??
+                    channel?.accounts?.[Object.keys(channel?.accounts ?? {}).find((key) => key.toLowerCase() === normalized.toLowerCase()) ?? ""];
+                return (account?.allowFrom ?? channel?.allowFrom ?? []).map((entry) => String(entry));
+            },
+            formatAllowFrom: ({ allowFrom }) => allowFrom
+                .map((entry) => String(entry).trim())
+                .filter(Boolean)
+                .map((entry) => entry
+                .replace(/^irc:/i, "")
+                .replace(/^user:/i, "")
+                .toLowerCase()),
+        },
+        groups: {
+            resolveRequireMention: ({ cfg, accountId, groupId }) => {
+                if (!groupId) {
+                    return true;
+                }
+                return resolveChannelGroupRequireMention({
+                    cfg,
+                    channel: "irc",
+                    groupId,
+                    accountId,
+                    groupIdCaseInsensitive: true,
+                });
+            },
+            resolveToolPolicy: ({ cfg, accountId, groupId, senderId, senderName, senderUsername }) => {
+                if (!groupId) {
+                    return undefined;
+                }
+                // IRC supports per-channel tool policies. Prefer the shared resolver so
+                // toolsBySender is honored consistently across surfaces.
+                return resolveChannelGroupToolsPolicy({
+                    cfg,
+                    channel: "irc",
+                    groupId,
+                    accountId,
+                    groupIdCaseInsensitive: true,
+                    senderId,
+                    senderName,
+                    senderUsername,
+                });
+            },
+        },
+    },
     googlechat: {
         id: "googlechat",
         capabilities: {
@@ -199,16 +296,22 @@ const DOCKS = {
             blockStreamingCoalesceDefaults: { minChars: 1500, idleMs: 1000 },
         },
         config: {
-            resolveAllowFrom: ({ cfg, accountId }) => (resolveSlackAccount({ cfg, accountId }).dm?.allowFrom ?? []).map((entry) => String(entry)),
+            resolveAllowFrom: ({ cfg, accountId }) => {
+                const account = resolveSlackAccount({ cfg, accountId });
+                return (account.config.allowFrom ?? account.dm?.allowFrom ?? []).map((entry) => String(entry));
+            },
             formatAllowFrom: ({ allowFrom }) => formatLower(allowFrom),
         },
         groups: {
             resolveRequireMention: resolveSlackGroupRequireMention,
             resolveToolPolicy: resolveSlackGroupToolPolicy,
         },
+        mentions: {
+            stripPatterns: () => ["<@[^>]+>"],
+        },
         threading: {
             resolveReplyToMode: ({ cfg, accountId, chatType }) => resolveSlackReplyToMode(resolveSlackAccount({ cfg, accountId }), chatType),
-            allowTagsWhenOff: true,
+            allowExplicitReplyTagsWhenOff: true,
             buildToolContext: (params) => buildSlackThreadingToolContext(params),
         },
     },
@@ -232,15 +335,7 @@ const DOCKS = {
                 .filter(Boolean),
         },
         threading: {
-            buildToolContext: ({ context, hasRepliedRef }) => {
-                const isDirect = context.ChatType?.toLowerCase() === "direct";
-                const channelId = (isDirect ? (context.From ?? context.To) : context.To)?.trim() || undefined;
-                return {
-                    currentChannelId: channelId,
-                    currentThreadTs: context.ReplyToId,
-                    hasRepliedRef,
-                };
-            },
+            buildToolContext: ({ context, hasRepliedRef }) => buildSignalThreadToolContext({ context, hasRepliedRef }),
         },
     },
     imessage: {
@@ -260,15 +355,7 @@ const DOCKS = {
             resolveToolPolicy: resolveIMessageGroupToolPolicy,
         },
         threading: {
-            buildToolContext: ({ context, hasRepliedRef }) => {
-                const isDirect = context.ChatType?.toLowerCase() === "direct";
-                const channelId = (isDirect ? (context.From ?? context.To) : context.To)?.trim() || undefined;
-                return {
-                    currentChannelId: channelId,
-                    currentThreadTs: context.ReplyToId,
-                    hasRepliedRef,
-                };
-            },
+            buildToolContext: ({ context, hasRepliedRef }) => buildIMessageThreadToolContext({ context, hasRepliedRef }),
         },
     },
 };
@@ -303,11 +390,13 @@ function listPluginDockEntries() {
     for (const entry of registry.channels) {
         const plugin = entry.plugin;
         const id = String(plugin.id).trim();
-        if (!id || seen.has(id))
+        if (!id || seen.has(id)) {
             continue;
+        }
         seen.add(id);
-        if (CHAT_CHANNEL_ORDER.includes(plugin.id))
+        if (CHAT_CHANNEL_ORDER.includes(plugin.id)) {
             continue;
+        }
         const dock = entry.dock ?? buildDockFromPlugin(plugin);
         entries.push({ id: plugin.id, dock, order: plugin.meta.order });
     }
@@ -326,19 +415,22 @@ export function listChannelDocks() {
         const indexB = CHAT_CHANNEL_ORDER.indexOf(b.id);
         const orderA = a.order ?? (indexA === -1 ? 999 : indexA);
         const orderB = b.order ?? (indexB === -1 ? 999 : indexB);
-        if (orderA !== orderB)
+        if (orderA !== orderB) {
             return orderA - orderB;
+        }
         return String(a.id).localeCompare(String(b.id));
     });
     return combined.map((entry) => entry.dock);
 }
 export function getChannelDock(id) {
     const core = DOCKS[id];
-    if (core)
+    if (core) {
         return core;
+    }
     const registry = requireActivePluginRegistry();
     const pluginEntry = registry.channels.find((entry) => entry.plugin.id === id);
-    if (!pluginEntry)
+    if (!pluginEntry) {
         return undefined;
+    }
     return pluginEntry.dock ?? buildDockFromPlugin(pluginEntry.plugin);
 }

package/dist/channels/draft-stream-loop.js

@@ -19,14 +19,18 @@ export function createDraftStreamLoop(params) {
                 return;
             }
             pendingText = "";
-            lastSentAt = Date.now();
             const current = params.sendOrEditStreamMessage(text).finally(() => {
                 if (inFlightPromise === current) {
                     inFlightPromise = undefined;
                 }
             });
             inFlightPromise = current;
-            await current;
+            const sent = await current;
+            if (sent === false) {
+                pendingText = text;
+                return;
+            }
+            lastSentAt = Date.now();
             if (!pendingText) {
                 return;
             }

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

@@ -1,6 +1,7 @@
-import { createActionGate, readNumberParam, readStringArrayParam, readStringOrNumberParam, readStringParam, } from "../../../agents/tools/common.js";
+import { readNumberParam, readStringArrayParam, readStringOrNumberParam, readStringParam, } from "../../../agents/tools/common.js";
 import { handleTelegramAction } from "../../../agents/tools/telegram-actions.js";
-import { listEnabledTelegramAccounts } from "../../../telegram/accounts.js";
+import { extractToolSend } from "../../../plugin-sdk/tool-send.js";
+import { createTelegramActionGate, listEnabledTelegramAccounts, } from "../../../telegram/accounts.js";
 import { isTelegramInlineButtonsEnabled } from "../../../telegram/inline-buttons.js";
 const providerId = "telegram";
 function readTelegramSendParams(params) {
@@ -14,6 +15,7 @@ function readTelegramSendParams(params) {
     const buttons = params.buttons;
     const asVoice = typeof params.asVoice === "boolean" ? params.asVoice : undefined;
     const silent = typeof params.silent === "boolean" ? params.silent : undefined;
+    const quoteText = readStringParam(params, "quoteText");
     return {
         to,
         content,
@@ -23,42 +25,46 @@ function readTelegramSendParams(params) {
         buttons,
         asVoice,
         silent,
+        quoteText: quoteText ?? undefined,
     };
 }
 export const telegramMessageActions = {
     listActions: ({ cfg }) => {
         const accounts = listEnabledTelegramAccounts(cfg).filter((account) => account.tokenSource !== "none");
-        if (accounts.length === 0)
+        if (accounts.length === 0) {
             return [];
-        const gate = createActionGate(cfg.channels?.telegram?.actions);
+        }
+        // Union of all accounts' action gates (any account enabling an action makes it available)
+        const gates = accounts.map((account) => createTelegramActionGate({ cfg, accountId: account.accountId }));
+        const gate = (key, defaultValue = true) => gates.some((g) => g(key, defaultValue));
         const actions = new Set(["send"]);
-        if (gate("reactions"))
+        if (gate("reactions")) {
             actions.add("react");
-        if (gate("deleteMessage"))
+        }
+        if (gate("deleteMessage")) {
             actions.add("delete");
-        if (gate("editMessage"))
+        }
+        if (gate("editMessage")) {
             actions.add("edit");
+        }
         if (gate("sticker", false)) {
             actions.add("sticker");
             actions.add("sticker-search");
         }
+        if (gate("createForumTopic")) {
+            actions.add("topic-create");
+        }
         return Array.from(actions);
     },
     supportsButtons: ({ cfg }) => {
         const accounts = listEnabledTelegramAccounts(cfg).filter((account) => account.tokenSource !== "none");
-        if (accounts.length === 0)
+        if (accounts.length === 0) {
             return false;
+        }
         return accounts.some((account) => isTelegramInlineButtonsEnabled({ cfg, accountId: account.accountId }));
     },
     extractToolSend: ({ args }) => {
-        const action = typeof args.action === "string" ? args.action.trim() : "";
-        if (action !== "sendMessage")
-            return null;
-        const to = typeof args.to === "string" ? args.to : undefined;
-        if (!to)
-            return null;
-        const accountId = typeof args.accountId === "string" ? args.accountId.trim() : undefined;
-        return { to, accountId };
+        return extractToolSend(args, "sendMessage");
     },
     handleAction: async ({ action, params, cfg, accountId }) => {
         if (action === "send") {
@@ -70,14 +76,16 @@ export const telegramMessageActions = {
             }, cfg);
         }
         if (action === "react") {
-            const messageId = readStringParam(params, "messageId", {
+            const messageId = readStringOrNumberParam(params, "messageId", {
                 required: true,
             });
             const emoji = readStringParam(params, "emoji", { allowEmpty: true });
             const remove = typeof params.remove === "boolean" ? params.remove : undefined;
             return await handleTelegramAction({
                 action: "react",
-                chatId: readStringParam(params, "chatId") ?? readStringParam(params, "to", { required: true }),
+                chatId: readStringOrNumberParam(params, "chatId") ??
+                    readStringOrNumberParam(params, "channelId") ??
+                    readStringParam(params, "to", { required: true }),
                 messageId,
                 emoji,
                 remove,
@@ -144,6 +152,22 @@ export const telegramMessageActions = {
                 accountId: accountId ?? undefined,
             }, cfg);
         }
+        if (action === "topic-create") {
+            const chatId = readStringOrNumberParam(params, "chatId") ??
+                readStringOrNumberParam(params, "channelId") ??
+                readStringParam(params, "to", { required: true });
+            const name = readStringParam(params, "name", { required: true });
+            const iconColor = readNumberParam(params, "iconColor", { integer: true });
+            const iconCustomEmojiId = readStringParam(params, "iconCustomEmojiId");
+            return await handleTelegramAction({
+                action: "createForumTopic",
+                chatId,
+                name,
+                iconColor: iconColor ?? undefined,
+                iconCustomEmojiId: iconCustomEmojiId ?? undefined,
+                accountId: accountId ?? undefined,
+            }, cfg);
+        }
         throw new Error(`Action ${action} is not supported for provider ${providerId}.`);
     },
 };

package/dist/channels/plugins/allowlist-match.js

@@ -1 +1 @@
-export { formatAllowlistMatchMeta } from "../allowlist-match.js";
+export { formatAllowlistMatchMeta, resolveAllowlistMatchSimple } from "../allowlist-match.js";