@poolzin/pool-bot 2026.2.24 → 2026.2.26

package/dist/utils/queue-helpers.js

@@ -1,6 +1,34 @@
+export function clearQueueSummaryState(state) {
+    state.droppedCount = 0;
+    state.summaryLines = [];
+}
+export function previewQueueSummaryPrompt(params) {
+    return buildQueueSummaryPrompt({
+        state: {
+            dropPolicy: params.state.dropPolicy,
+            droppedCount: params.state.droppedCount,
+            summaryLines: [...params.state.summaryLines],
+        },
+        noun: params.noun,
+        title: params.title,
+    });
+}
+export function applyQueueRuntimeSettings(params) {
+    params.target.mode = params.settings.mode;
+    params.target.debounceMs =
+        typeof params.settings.debounceMs === "number"
+            ? Math.max(0, params.settings.debounceMs)
+            : params.target.debounceMs;
+    params.target.cap =
+        typeof params.settings.cap === "number" && params.settings.cap > 0
+            ? Math.floor(params.settings.cap)
+            : params.target.cap;
+    params.target.dropPolicy = params.settings.dropPolicy ?? params.target.dropPolicy;
+}
 export function elideQueueText(text, limit = 140) {
-    if (text.length <= limit)
+    if (text.length <= limit) {
         return text;
+    }
     return `${text.slice(0, Math.max(0, limit - 1)).trimEnd()}…`;
 }
 export function buildQueueSummaryLine(text, limit = 160) {
@@ -8,16 +36,19 @@ export function buildQueueSummaryLine(text, limit = 160) {
     return elideQueueText(cleaned, limit);
 }
 export function shouldSkipQueueItem(params) {
-    if (!params.dedupe)
+    if (!params.dedupe) {
         return false;
+    }
     return params.dedupe(params.item, params.items);
 }
 export function applyQueueDropPolicy(params) {
     const cap = params.queue.cap;
-    if (cap <= 0 || params.queue.items.length < cap)
+    if (cap <= 0 || params.queue.items.length < cap) {
         return true;
-    if (params.queue.dropPolicy === "new")
+    }
+    if (params.queue.dropPolicy === "new") {
         return false;
+    }
     const dropCount = params.queue.items.length - cap + 1;
     const dropped = params.queue.items.splice(0, dropCount);
     if (params.queue.dropPolicy === "summarize") {
@@ -26,15 +57,17 @@ export function applyQueueDropPolicy(params) {
             params.queue.summaryLines.push(buildQueueSummaryLine(params.summarize(item)));
         }
         const limit = Math.max(0, params.summaryLimit ?? cap);
-        while (params.queue.summaryLines.length > limit)
+        while (params.queue.summaryLines.length > limit) {
             params.queue.summaryLines.shift();
+        }
     }
     return true;
 }
 export function waitForQueueDebounce(queue) {
     const debounceMs = Math.max(0, queue.debounceMs);
-    if (debounceMs <= 0)
+    if (debounceMs <= 0) {
         return Promise.resolve();
+    }
     return new Promise((resolve) => {
         const check = () => {
             const since = Date.now() - queue.lastEnqueuedAt;
@@ -47,6 +80,25 @@ export function waitForQueueDebounce(queue) {
         check();
     });
 }
+export async function drainNextQueueItem(items, run) {
+    const next = items[0];
+    if (!next) {
+        return false;
+    }
+    await run(next);
+    items.shift();
+    return true;
+}
+export async function drainCollectItemIfNeeded(params) {
+    if (!params.forceIndividualCollect && !params.isCrossChannel) {
+        return "skipped";
+    }
+    if (params.isCrossChannel) {
+        params.setForceIndividualCollect?.(true);
+    }
+    const drained = await drainNextQueueItem(params.items, params.run);
+    return drained ? "drained" : "empty";
+}
 export function buildQueueSummaryPrompt(params) {
     if (params.state.dropPolicy !== "summarize" || params.state.droppedCount <= 0) {
         return undefined;
@@ -61,14 +113,14 @@ export function buildQueueSummaryPrompt(params) {
             lines.push(`- ${line}`);
         }
     }
-    params.state.droppedCount = 0;
-    params.state.summaryLines = [];
+    clearQueueSummaryState(params.state);
     return lines.join("\n");
 }
 export function buildCollectPrompt(params) {
     const blocks = [params.title];
-    if (params.summary)
+    if (params.summary) {
         blocks.push(params.summary);
+    }
     params.items.forEach((item, idx) => {
         blocks.push(params.renderItem(item, idx));
     });
@@ -79,17 +131,20 @@ export function hasCrossChannelItems(items, resolveKey) {
     let hasUnkeyed = false;
     for (const item of items) {
         const resolved = resolveKey(item);
-        if (resolved.cross)
+        if (resolved.cross) {
             return true;
+        }
         if (!resolved.key) {
             hasUnkeyed = true;
             continue;
         }
         keys.add(resolved.key);
     }
-    if (keys.size === 0)
+    if (keys.size === 0) {
         return false;
-    if (hasUnkeyed)
+    }
+    if (hasUnkeyed) {
         return true;
+    }
     return keys.size > 1;
 }

package/dist/utils/run-with-concurrency.js

@@ -0,0 +1,39 @@
+export async function runTasksWithConcurrency(params) {
+    const { tasks, limit, onTaskError } = params;
+    const errorMode = params.errorMode ?? "continue";
+    if (tasks.length === 0) {
+        return { results: [], firstError: undefined, hasError: false };
+    }
+    const resolvedLimit = Math.max(1, Math.min(limit, tasks.length));
+    const results = Array.from({ length: tasks.length });
+    let next = 0;
+    let firstError = undefined;
+    let hasError = false;
+    const workers = Array.from({ length: resolvedLimit }, async () => {
+        while (true) {
+            if (errorMode === "stop" && hasError) {
+                return;
+            }
+            const index = next;
+            next += 1;
+            if (index >= tasks.length) {
+                return;
+            }
+            try {
+                results[index] = await tasks[index]();
+            }
+            catch (error) {
+                if (!hasError) {
+                    firstError = error;
+                    hasError = true;
+                }
+                onTaskError?.(error, index);
+                if (errorMode === "stop") {
+                    return;
+                }
+            }
+        }
+    });
+    await Promise.allSettled(workers);
+    return { results, firstError, hasError };
+}

package/dist/web/auto-reply/deliver-reply.js

@@ -1,6 +1,8 @@
 import { chunkMarkdownTextWithMode } from "../../auto-reply/chunk.js";
-import { convertMarkdownTables } from "../../markdown/tables.js";
 import { logVerbose, shouldLogVerbose } from "../../globals.js";
+import { convertMarkdownTables } from "../../markdown/tables.js";
+import { markdownToWhatsApp } from "../../markdown/whatsapp.js";
+import { sleep } from "../../utils.js";
 import { loadWebMedia } from "../media.js";
 import { newConnectionId } from "../reconnect.js";
 import { formatError } from "../session.js";
@@ -11,14 +13,13 @@ export async function deliverWebReply(params) {
     const replyStarted = Date.now();
     const tableMode = params.tableMode ?? "code";
     const chunkMode = params.chunkMode ?? "length";
-    const convertedText = convertMarkdownTables(replyResult.text || "", tableMode);
+    const convertedText = markdownToWhatsApp(convertMarkdownTables(replyResult.text || "", tableMode));
     const textChunks = chunkMarkdownTextWithMode(convertedText, textLimit, chunkMode);
     const mediaList = replyResult.mediaUrls?.length
         ? replyResult.mediaUrls
         : replyResult.mediaUrl
             ? [replyResult.mediaUrl]
             : [];
-    const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
     const sendWithRetry = async (fn, label, maxAttempts = 3) => {
         let lastErr;
         for (let attempt = 1; attempt <= maxAttempts; attempt++) {
@@ -69,7 +70,10 @@ export async function deliverWebReply(params) {
     for (const [index, mediaUrl] of mediaList.entries()) {
         const caption = index === 0 ? remainingText.shift() || undefined : undefined;
         try {
-            const media = await loadWebMedia(mediaUrl, maxMediaBytes);
+            const media = await loadWebMedia(mediaUrl, {
+                maxBytes: maxMediaBytes,
+                localRoots: params.mediaLocalRoots,
+            });
             if (shouldLogVerbose()) {
                 logVerbose(`Web auto-reply media size: ${(media.buffer.length / (1024 * 1024)).toFixed(2)}MB`);
                 logVerbose(`Web auto-reply media source: ${mediaUrl} (kind ${media.kind})`);

package/dist/web/auto-reply/mentions.js

@@ -20,12 +20,14 @@ export function isBotMentionedFromTargets(msg, mentionCfg, targets) {
     const isSelfChat = isSelfChatMode(targets.selfE164, mentionCfg.allowFrom);
     const hasMentions = (msg.mentionedJids?.length ?? 0) > 0;
     if (hasMentions && !isSelfChat) {
-        if (targets.selfE164 && targets.normalizedMentions.includes(targets.selfE164))
+        if (targets.selfE164 && targets.normalizedMentions.includes(targets.selfE164)) {
             return true;
+        }
         if (targets.selfJid) {
             // Some mentions use the bare JID; match on E.164 to be safe.
-            if (targets.normalizedMentions.includes(targets.selfJid))
+            if (targets.normalizedMentions.includes(targets.selfJid)) {
                 return true;
+            }
         }
         // If the message explicitly mentions someone else, do not fall back to regex matches.
         return false;
@@ -34,19 +36,22 @@ export function isBotMentionedFromTargets(msg, mentionCfg, targets) {
         // Self-chat mode: ignore WhatsApp @mention JIDs, otherwise @mentioning the owner in group chats triggers the bot.
     }
     const bodyClean = clean(msg.body);
-    if (mentionCfg.mentionRegexes.some((re) => re.test(bodyClean)))
+    if (mentionCfg.mentionRegexes.some((re) => re.test(bodyClean))) {
         return true;
+    }
     // Fallback: detect body containing our own number (with or without +, spacing)
     if (targets.selfE164) {
         const selfDigits = targets.selfE164.replace(/\D/g, "");
         if (selfDigits) {
             const bodyDigits = bodyClean.replace(/[^\d]/g, "");
-            if (bodyDigits.includes(selfDigits))
+            if (bodyDigits.includes(selfDigits)) {
                 return true;
+            }
             const bodyNoSpace = msg.body.replace(/[\s-]/g, "");
             const pattern = new RegExp(`\\+?${selfDigits}`, "i");
-            if (pattern.test(bodyNoSpace))
+            if (pattern.test(bodyNoSpace)) {
                 return true;
+            }
         }
     }
     return false;

package/dist/web/auto-reply/monitor/group-members.js

@@ -1,11 +1,13 @@
 import { normalizeE164 } from "../../../utils.js";
 export function noteGroupMember(groupMemberNames, conversationId, e164, name) {
-    if (!e164 || !name)
+    if (!e164 || !name) {
         return;
+    }
     const normalized = normalizeE164(e164);
     const key = normalized ?? e164;
-    if (!key)
+    if (!key) {
         return;
+    }
     let roster = groupMemberNames.get(conversationId);
     if (!roster) {
         roster = new Map();
@@ -19,11 +21,13 @@ export function formatGroupMembers(params) {
     const ordered = [];
     if (participants?.length) {
         for (const entry of participants) {
-            if (!entry)
+            if (!entry) {
                 continue;
+            }
             const normalized = normalizeE164(entry) ?? entry;
-            if (!normalized || seen.has(normalized))
+            if (!normalized || seen.has(normalized)) {
                 continue;
+            }
             seen.add(normalized);
             ordered.push(normalized);
         }
@@ -31,19 +35,22 @@ export function formatGroupMembers(params) {
     if (roster) {
         for (const entry of roster.keys()) {
             const normalized = normalizeE164(entry) ?? entry;
-            if (!normalized || seen.has(normalized))
+            if (!normalized || seen.has(normalized)) {
                 continue;
+            }
             seen.add(normalized);
             ordered.push(normalized);
         }
     }
     if (ordered.length === 0 && fallbackE164) {
         const normalized = normalizeE164(fallbackE164) ?? fallbackE164;
-        if (normalized)
+        if (normalized) {
             ordered.push(normalized);
+        }
     }
-    if (ordered.length === 0)
+    if (ordered.length === 0) {
         return undefined;
+    }
     return ordered
         .map((entry) => {
         const name = roster?.get(entry);

package/dist/web/auto-reply/monitor/process-message.js

@@ -1,17 +1,19 @@
 import { resolveIdentityNamePrefix } from "../../../agents/identity.js";
 import { resolveChunkMode, resolveTextChunkLimit } from "../../../auto-reply/chunk.js";
+import { shouldComputeCommandAuthorized } from "../../../auto-reply/command-detection.js";
 import { formatInboundEnvelope, resolveEnvelopeFormatOptions, } from "../../../auto-reply/envelope.js";
 import { buildHistoryContextFromEntries, } from "../../../auto-reply/reply/history.js";
-import { dispatchReplyWithBufferedBlockDispatcher } from "../../../auto-reply/reply/provider-dispatcher.js";
-import { shouldComputeCommandAuthorized } from "../../../auto-reply/command-detection.js";
 import { finalizeInboundContext } from "../../../auto-reply/reply/inbound-context.js";
+import { dispatchReplyWithBufferedBlockDispatcher } from "../../../auto-reply/reply/provider-dispatcher.js";
 import { toLocationContext } from "../../../channels/location.js";
-import { createReplyPrefixContext } from "../../../channels/reply-prefix.js";
-import { readSessionUpdatedAt, recordSessionMetaFromInbound, resolveStorePath, } from "../../../config/sessions.js";
+import { createReplyPrefixOptions } from "../../../channels/reply-prefix.js";
 import { resolveMarkdownTableMode } from "../../../config/markdown-tables.js";
+import { readSessionUpdatedAt, recordSessionMetaFromInbound, resolveStorePath, } from "../../../config/sessions.js";
 import { logVerbose, shouldLogVerbose } from "../../../globals.js";
+import { getAgentScopedMediaLocalRoots } from "../../../media/local-roots.js";
 import { readChannelAllowFromStore } from "../../../pairing/pairing-store.js";
 import { jidToE164, normalizeE164 } from "../../../utils.js";
+import { resolveWhatsAppAccount } from "../../accounts.js";
 import { newConnectionId } from "../../reconnect.js";
 import { formatError } from "../../session.js";
 import { deliverWebReply } from "../deliver-reply.js";
@@ -31,31 +33,39 @@ function normalizeAllowFromE164(values) {
 }
 async function resolveWhatsAppCommandAuthorized(params) {
     const useAccessGroups = params.cfg.commands?.useAccessGroups !== false;
-    if (!useAccessGroups)
+    if (!useAccessGroups) {
         return true;
+    }
     const isGroup = params.msg.chatType === "group";
     const senderE164 = normalizeE164(isGroup ? (params.msg.senderE164 ?? "") : (params.msg.senderE164 ?? params.msg.from ?? ""));
-    if (!senderE164)
+    if (!senderE164) {
         return false;
-    const configuredAllowFrom = params.cfg.channels?.whatsapp?.allowFrom ?? [];
-    const configuredGroupAllowFrom = params.cfg.channels?.whatsapp?.groupAllowFrom ??
-        (configuredAllowFrom.length > 0 ? configuredAllowFrom : undefined);
+    }
+    const account = resolveWhatsAppAccount({ cfg: params.cfg, accountId: params.msg.accountId });
+    const dmPolicy = account.dmPolicy ?? "pairing";
+    const configuredAllowFrom = account.allowFrom ?? [];
+    const configuredGroupAllowFrom = account.groupAllowFrom ?? (configuredAllowFrom.length > 0 ? configuredAllowFrom : undefined);
     if (isGroup) {
-        if (!configuredGroupAllowFrom || configuredGroupAllowFrom.length === 0)
+        if (!configuredGroupAllowFrom || configuredGroupAllowFrom.length === 0) {
             return false;
-        if (configuredGroupAllowFrom.some((v) => String(v).trim() === "*"))
+        }
+        if (configuredGroupAllowFrom.some((v) => String(v).trim() === "*")) {
             return true;
+        }
         return normalizeAllowFromE164(configuredGroupAllowFrom).includes(senderE164);
     }
-    const storeAllowFrom = await readChannelAllowFromStore("whatsapp").catch(() => []);
+    const storeAllowFrom = dmPolicy === "allowlist"
+        ? []
+        : await readChannelAllowFromStore("whatsapp", process.env, params.msg.accountId).catch(() => []);
     const combinedAllowFrom = Array.from(new Set([...(configuredAllowFrom ?? []), ...storeAllowFrom]));
     const allowFrom = combinedAllowFrom.length > 0
         ? combinedAllowFrom
         : params.msg.selfE164
             ? [params.msg.selfE164]
             : [];
-    if (allowFrom.some((v) => String(v).trim() === "*"))
+    if (allowFrom.some((v) => String(v).trim() === "*")) {
         return true;
+    }
     return normalizeAllowFromE164(allowFrom).includes(senderE164);
 }
 export async function processMessage(params) {
@@ -83,21 +93,17 @@ export async function processMessage(params) {
                 sender: m.sender,
                 body: m.body,
                 timestamp: m.timestamp,
-                messageId: m.id,
             }));
             combinedBody = buildHistoryContextFromEntries({
                 entries: historyEntries,
                 currentMessage: combinedBody,
                 excludeLast: false,
                 formatEntry: (entry) => {
-                    const bodyWithId = entry.messageId
-                        ? `${entry.body}\n[message_id: ${entry.messageId}]`
-                        : entry.body;
                     return formatInboundEnvelope({
                         channel: "WhatsApp",
                         from: conversationId,
                         timestamp: entry.timestamp,
-                        body: bodyWithId,
+                        body: entry.body,
                         chatType: "group",
                         senderLabel: entry.sender,
                         envelope: envelopeOptions,
@@ -147,11 +153,13 @@ export async function processMessage(params) {
     }
     const dmRouteTarget = params.msg.chatType !== "group"
         ? (() => {
-            if (params.msg.senderE164)
+            if (params.msg.senderE164) {
                 return normalizeE164(params.msg.senderE164);
+            }
             // In direct chats, `msg.from` is already the canonical conversation id.
-            if (params.msg.from.includes("@"))
+            if (params.msg.from.includes("@")) {
                 return jidToE164(params.msg.from);
+            }
             return normalizeE164(params.msg.from);
         })()
         : undefined;
@@ -162,25 +170,37 @@ export async function processMessage(params) {
         channel: "whatsapp",
         accountId: params.route.accountId,
     });
+    const mediaLocalRoots = getAgentScopedMediaLocalRoots(params.cfg, params.route.agentId);
     let didLogHeartbeatStrip = false;
     let didSendReply = false;
     const commandAuthorized = shouldComputeCommandAuthorized(params.msg.body, params.cfg)
         ? await resolveWhatsAppCommandAuthorized({ cfg: params.cfg, msg: params.msg })
         : undefined;
     const configuredResponsePrefix = params.cfg.messages?.responsePrefix;
-    const prefixContext = createReplyPrefixContext({
+    const { onModelSelected, ...prefixOptions } = createReplyPrefixOptions({
         cfg: params.cfg,
         agentId: params.route.agentId,
+        channel: "whatsapp",
+        accountId: params.route.accountId,
     });
     const isSelfChat = params.msg.chatType !== "group" &&
         Boolean(params.msg.selfE164) &&
         normalizeE164(params.msg.from) === normalizeE164(params.msg.selfE164 ?? "");
-    const responsePrefix = prefixContext.responsePrefix ??
+    const responsePrefix = prefixOptions.responsePrefix ??
         (configuredResponsePrefix === undefined && isSelfChat
             ? (resolveIdentityNamePrefix(params.cfg, params.route.agentId) ?? "[poolbot]")
             : undefined);
+    const inboundHistory = params.msg.chatType === "group"
+        ? (params.groupHistory ?? params.groupHistories.get(params.groupHistoryKey) ?? []).map((entry) => ({
+            sender: entry.sender,
+            body: entry.body,
+            timestamp: entry.timestamp,
+        }))
+        : undefined;
     const ctxPayload = finalizeInboundContext({
         Body: combinedBody,
+        BodyForAgent: params.msg.body,
+        InboundHistory: inboundHistory,
         RawBody: params.msg.body,
         CommandBody: params.msg.body,
         From: params.msg.from,
@@ -243,8 +263,8 @@ export async function processMessage(params) {
         cfg: params.cfg,
         replyResolver: params.replyResolver,
         dispatcherOptions: {
+            ...prefixOptions,
             responsePrefix,
-            responsePrefixContextProvider: prefixContext.responsePrefixContextProvider,
             onHeartbeatStrip: () => {
                 if (!didLogHeartbeatStrip) {
                     didLogHeartbeatStrip = true;
@@ -255,6 +275,7 @@ export async function processMessage(params) {
                 await deliverWebReply({
                     replyResult: payload,
                     msg: params.msg,
+                    mediaLocalRoots,
                     maxMediaBytes: params.maxMediaBytes,
                     textLimit,
                     chunkMode,
@@ -299,7 +320,7 @@ export async function processMessage(params) {
             disableBlockStreaming: typeof params.cfg.channels?.whatsapp?.blockStreaming === "boolean"
                 ? !params.cfg.channels.whatsapp.blockStreaming
                 : undefined,
-            onModelSelected: prefixContext.onModelSelected,
+            onModelSelected,
         },
     });
     if (!queuedFinal) {

package/dist/web/inbound/access-control.js

@@ -11,9 +11,11 @@ export async function checkInboundAccessControl(params) {
         cfg,
         accountId: params.accountId,
     });
-    const dmPolicy = cfg.channels?.whatsapp?.dmPolicy ?? "pairing";
+    const dmPolicy = account.dmPolicy ?? "pairing";
     const configuredAllowFrom = account.allowFrom;
-    const storeAllowFrom = await readChannelAllowFromStore("whatsapp").catch(() => []);
+    const storeAllowFrom = dmPolicy === "allowlist"
+        ? []
+        : await readChannelAllowFromStore("whatsapp", process.env, account.accountId).catch(() => []);
     // Without user config, default to self-only DM access so the owner can talk to themselves.
     const combinedAllowFrom = Array.from(new Set([...(configuredAllowFrom ?? []), ...storeAllowFrom]));
     const defaultAllowFrom = combinedAllowFrom.length === 0 && params.selfE164 ? [params.selfE164] : undefined;
@@ -107,6 +109,7 @@ export async function checkInboundAccessControl(params) {
                         const { code, created } = await upsertChannelPairingRequest({
                             channel: "whatsapp",
                             id: candidate,
+                            accountId: account.accountId,
                             meta: { name: (params.pushName ?? "").trim() || undefined },
                         });
                         if (created) {

package/dist/web/login-qr.js

@@ -34,20 +34,23 @@ function attachLoginWaiter(accountId, login) {
     login.waitPromise = waitForWaConnection(login.sock)
         .then(() => {
         const current = activeLogins.get(accountId);
-        if (current?.id === login.id)
+        if (current?.id === login.id) {
             current.connected = true;
+        }
     })
         .catch((err) => {
         const current = activeLogins.get(accountId);
-        if (current?.id !== login.id)
+        if (current?.id !== login.id) {
             return;
+        }
         current.error = formatError(err);
         current.errorStatus = getStatusCode(err);
     });
 }
 async function restartLoginSocket(login, runtime) {
-    if (login.restartAttempted)
+    if (login.restartAttempted) {
         return false;
+    }
     login.restartAttempted = true;
     runtime.log(info("WhatsApp asked for a restart after pairing (code 515); retrying connection once…"));
     closeSocket(login.sock);
@@ -103,12 +106,14 @@ export async function startWebLoginWithQr(opts = {}) {
         sock = await createWaSocket(false, Boolean(opts.verbose), {
             authDir: account.authDir,
             onQr: (qr) => {
-                if (pendingQr)
+                if (pendingQr) {
                     return;
+                }
                 pendingQr = qr;
                 const current = activeLogins.get(account.accountId);
-                if (current && !current.qr)
+                if (current && !current.qr) {
                     current.qr = qr;
+                }
                 clearTimeout(qrTimer);
                 runtime.log(info("WhatsApp QR received."));
                 resolveQr?.(qr);
@@ -135,8 +140,9 @@ export async function startWebLoginWithQr(opts = {}) {
         verbose: Boolean(opts.verbose),
     };
     activeLogins.set(account.accountId, login);
-    if (pendingQr && !login.qr)
+    if (pendingQr && !login.qr) {
         login.qr = pendingQr;
+    }
     attachLoginWaiter(account.accountId, login);
     let qr;
     try {