@poolzin/pool-bot 2026.3.25 → 2026.3.26

package/dist/auto-reply/auto-reply/reply/reply-dispatcher.js

@@ -0,0 +1,152 @@
+import { sleep } from "../../utils.js";
+import { registerDispatcher } from "./dispatcher-registry.js";
+import { normalizeReplyPayload } from "./normalize-reply.js";
+const DEFAULT_HUMAN_DELAY_MIN_MS = 800;
+const DEFAULT_HUMAN_DELAY_MAX_MS = 2500;
+/** Generate a random delay within the configured range. */
+function getHumanDelay(config) {
+    const mode = config?.mode ?? "off";
+    if (mode === "off") {
+        return 0;
+    }
+    const min = mode === "custom" ? (config?.minMs ?? DEFAULT_HUMAN_DELAY_MIN_MS) : DEFAULT_HUMAN_DELAY_MIN_MS;
+    const max = mode === "custom" ? (config?.maxMs ?? DEFAULT_HUMAN_DELAY_MAX_MS) : DEFAULT_HUMAN_DELAY_MAX_MS;
+    if (max <= min) {
+        return min;
+    }
+    return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+function normalizeReplyPayloadInternal(payload, opts) {
+    // Prefer dynamic context provider over static context
+    const prefixContext = opts.responsePrefixContextProvider?.() ?? opts.responsePrefixContext;
+    return normalizeReplyPayload(payload, {
+        responsePrefix: opts.responsePrefix,
+        responsePrefixContext: prefixContext,
+        onHeartbeatStrip: opts.onHeartbeatStrip,
+        onSkip: opts.onSkip,
+    });
+}
+export function createReplyDispatcher(options) {
+    let sendChain = Promise.resolve();
+    // Track in-flight deliveries so we can emit a reliable "idle" signal.
+    // Start with pending=1 as a "reservation" to prevent premature gateway restart.
+    // This is decremented when markComplete() is called to signal no more replies will come.
+    let pending = 1;
+    let completeCalled = false;
+    // Track whether we've sent a block reply (for human delay - skip delay on first block).
+    let sentFirstBlock = false;
+    // Serialize outbound replies to preserve tool/block/final order.
+    const queuedCounts = {
+        tool: 0,
+        block: 0,
+        final: 0,
+    };
+    // Register this dispatcher globally for gateway restart coordination.
+    const { unregister } = registerDispatcher({
+        pending: () => pending,
+        waitForIdle: () => sendChain,
+    });
+    const enqueue = (kind, payload) => {
+        const normalized = normalizeReplyPayloadInternal(payload, {
+            responsePrefix: options.responsePrefix,
+            responsePrefixContext: options.responsePrefixContext,
+            responsePrefixContextProvider: options.responsePrefixContextProvider,
+            onHeartbeatStrip: options.onHeartbeatStrip,
+            onSkip: (reason) => options.onSkip?.(payload, { kind, reason }),
+        });
+        if (!normalized) {
+            return false;
+        }
+        queuedCounts[kind] += 1;
+        pending += 1;
+        // Determine if we should add human-like delay (only for block replies after the first).
+        const shouldDelay = kind === "block" && sentFirstBlock;
+        if (kind === "block") {
+            sentFirstBlock = true;
+        }
+        sendChain = sendChain
+            .then(async () => {
+            // Add human-like delay between block replies for natural rhythm.
+            if (shouldDelay) {
+                const delayMs = getHumanDelay(options.humanDelay);
+                if (delayMs > 0) {
+                    await sleep(delayMs);
+                }
+            }
+            // Safe: deliver is called inside an async .then() callback, so even a synchronous
+            // throw becomes a rejection that flows through .catch()/.finally(), ensuring cleanup.
+            await options.deliver(normalized, { kind });
+        })
+            .catch((err) => {
+            options.onError?.(err, { kind });
+        })
+            .finally(() => {
+            pending -= 1;
+            // Clear reservation if:
+            // 1. pending is now 1 (just the reservation left)
+            // 2. markComplete has been called
+            // 3. No more replies will be enqueued
+            if (pending === 1 && completeCalled) {
+                pending -= 1; // Clear the reservation
+            }
+            if (pending === 0) {
+                // Unregister from global tracking when idle.
+                unregister();
+                options.onIdle?.();
+            }
+        });
+        return true;
+    };
+    const markComplete = () => {
+        if (completeCalled) {
+            return;
+        }
+        completeCalled = true;
+        // If no replies were enqueued (pending is still 1 = just the reservation),
+        // schedule clearing the reservation after current microtasks complete.
+        // This gives any in-flight enqueue() calls a chance to increment pending.
+        void Promise.resolve().then(() => {
+            if (pending === 1 && completeCalled) {
+                // Still just the reservation, no replies were enqueued
+                pending -= 1;
+                if (pending === 0) {
+                    unregister();
+                    options.onIdle?.();
+                }
+            }
+        });
+    };
+    return {
+        sendToolResult: (payload) => enqueue("tool", payload),
+        sendBlockReply: (payload) => enqueue("block", payload),
+        sendFinalReply: (payload) => enqueue("final", payload),
+        waitForIdle: () => sendChain,
+        getQueuedCounts: () => ({ ...queuedCounts }),
+        markComplete,
+    };
+}
+export function createReplyDispatcherWithTyping(options) {
+    const { onReplyStart, onIdle, onCleanup, ...dispatcherOptions } = options;
+    let typingController;
+    const dispatcher = createReplyDispatcher({
+        ...dispatcherOptions,
+        onIdle: () => {
+            typingController?.markDispatchIdle();
+            onIdle?.();
+        },
+    });
+    return {
+        dispatcher,
+        replyOptions: {
+            onReplyStart,
+            onTypingCleanup: onCleanup,
+            onTypingController: (typing) => {
+                typingController = typing;
+            },
+        },
+        markDispatchIdle: () => {
+            typingController?.markDispatchIdle();
+            onIdle?.();
+        },
+    };
+}

package/dist/auto-reply/auto-reply/reply/reply-elevated.js

@@ -0,0 +1,166 @@
+import { resolveAgentConfig } from "../../agents/agent-scope.js";
+import { getChannelDock } from "../../channels/dock.js";
+import { normalizeChannelId } from "../../channels/plugins/index.js";
+import { CHAT_CHANNEL_ORDER } from "../../channels/registry.js";
+import { INTERNAL_MESSAGE_CHANNEL } from "../../utils/message-channel.js";
+import { formatCliCommand } from "../../cli/command-format.js";
+function normalizeAllowToken(value) {
+    if (!value)
+        return "";
+    return value.trim().toLowerCase();
+}
+function slugAllowToken(value) {
+    if (!value)
+        return "";
+    let text = value.trim().toLowerCase();
+    if (!text)
+        return "";
+    text = text.replace(/^[@#]+/, "");
+    text = text.replace(/[\s_]+/g, "-");
+    text = text.replace(/[^a-z0-9-]+/g, "-");
+    return text.replace(/-{2,}/g, "-").replace(/^-+|-+$/g, "");
+}
+const SENDER_PREFIXES = [
+    ...CHAT_CHANNEL_ORDER,
+    INTERNAL_MESSAGE_CHANNEL,
+    "user",
+    "group",
+    "channel",
+];
+const SENDER_PREFIX_RE = new RegExp(`^(${SENDER_PREFIXES.join("|")}):`, "i");
+function stripSenderPrefix(value) {
+    if (!value)
+        return "";
+    const trimmed = value.trim();
+    return trimmed.replace(SENDER_PREFIX_RE, "");
+}
+function resolveElevatedAllowList(allowFrom, provider, fallbackAllowFrom) {
+    if (!allowFrom)
+        return fallbackAllowFrom;
+    const value = allowFrom[provider];
+    return Array.isArray(value) ? value : fallbackAllowFrom;
+}
+function isApprovedElevatedSender(params) {
+    const rawAllow = resolveElevatedAllowList(params.allowFrom, params.provider, params.fallbackAllowFrom);
+    if (!rawAllow || rawAllow.length === 0)
+        return false;
+    const allowTokens = rawAllow.map((entry) => String(entry).trim()).filter(Boolean);
+    if (allowTokens.length === 0)
+        return false;
+    if (allowTokens.some((entry) => entry === "*"))
+        return true;
+    const tokens = new Set();
+    const addToken = (value) => {
+        if (!value)
+            return;
+        const trimmed = value.trim();
+        if (!trimmed)
+            return;
+        tokens.add(trimmed);
+        const normalized = normalizeAllowToken(trimmed);
+        if (normalized)
+            tokens.add(normalized);
+        const slugged = slugAllowToken(trimmed);
+        if (slugged)
+            tokens.add(slugged);
+    };
+    addToken(params.ctx.SenderName);
+    addToken(params.ctx.SenderUsername);
+    addToken(params.ctx.SenderTag);
+    addToken(params.ctx.SenderE164);
+    addToken(params.ctx.From);
+    addToken(stripSenderPrefix(params.ctx.From));
+    addToken(params.ctx.To);
+    addToken(stripSenderPrefix(params.ctx.To));
+    for (const rawEntry of allowTokens) {
+        const entry = rawEntry.trim();
+        if (!entry)
+            continue;
+        const stripped = stripSenderPrefix(entry);
+        if (tokens.has(entry) || tokens.has(stripped))
+            return true;
+        const normalized = normalizeAllowToken(stripped);
+        if (normalized && tokens.has(normalized))
+            return true;
+        const slugged = slugAllowToken(stripped);
+        if (slugged && tokens.has(slugged))
+            return true;
+    }
+    return false;
+}
+export function resolveElevatedPermissions(params) {
+    const globalConfig = params.cfg.tools?.elevated;
+    const agentConfig = resolveAgentConfig(params.cfg, params.agentId)?.tools?.elevated;
+    const globalEnabled = globalConfig?.enabled !== false;
+    const agentEnabled = agentConfig?.enabled !== false;
+    const enabled = globalEnabled && agentEnabled;
+    const failures = [];
+    if (!globalEnabled)
+        failures.push({ gate: "enabled", key: "tools.elevated.enabled" });
+    if (!agentEnabled)
+        failures.push({
+            gate: "enabled",
+            key: "agents.list[].tools.elevated.enabled",
+        });
+    if (!enabled)
+        return { enabled, allowed: false, failures };
+    if (!params.provider) {
+        failures.push({ gate: "provider", key: "ctx.Provider" });
+        return { enabled, allowed: false, failures };
+    }
+    const normalizedProvider = normalizeChannelId(params.provider);
+    const dockFallbackAllowFrom = normalizedProvider
+        ? getChannelDock(normalizedProvider)?.elevated?.allowFromFallback?.({
+            cfg: params.cfg,
+            accountId: params.ctx.AccountId,
+        })
+        : undefined;
+    const fallbackAllowFrom = dockFallbackAllowFrom;
+    const globalAllowed = isApprovedElevatedSender({
+        provider: params.provider,
+        ctx: params.ctx,
+        allowFrom: globalConfig?.allowFrom,
+        fallbackAllowFrom,
+    });
+    if (!globalAllowed) {
+        failures.push({
+            gate: "allowFrom",
+            key: `tools.elevated.allowFrom.${params.provider}`,
+        });
+        return { enabled, allowed: false, failures };
+    }
+    const agentAllowed = agentConfig?.allowFrom
+        ? isApprovedElevatedSender({
+            provider: params.provider,
+            ctx: params.ctx,
+            allowFrom: agentConfig.allowFrom,
+            fallbackAllowFrom,
+        })
+        : true;
+    if (!agentAllowed) {
+        failures.push({
+            gate: "allowFrom",
+            key: `agents.list[].tools.elevated.allowFrom.${params.provider}`,
+        });
+    }
+    return { enabled, allowed: globalAllowed && agentAllowed, failures };
+}
+export function formatElevatedUnavailableMessage(params) {
+    const lines = [];
+    lines.push(`elevated is not available right now (runtime=${params.runtimeSandboxed ? "sandboxed" : "direct"}).`);
+    if (params.failures.length > 0) {
+        lines.push(`Failing gates: ${params.failures.map((f) => `${f.gate} (${f.key})`).join(", ")}`);
+    }
+    else {
+        lines.push("Failing gates: enabled (tools.elevated.enabled / agents.list[].tools.elevated.enabled), allowFrom (tools.elevated.allowFrom.<provider>).");
+    }
+    lines.push("Fix-it keys:");
+    lines.push("- tools.elevated.enabled");
+    lines.push("- tools.elevated.allowFrom.<provider>");
+    lines.push("- agents.list[].tools.elevated.enabled");
+    lines.push("- agents.list[].tools.elevated.allowFrom.<provider>");
+    if (params.sessionKey) {
+        lines.push(`See: ${formatCliCommand(`poolbot sandbox explain --session ${params.sessionKey}`)}`);
+    }
+    return lines.join("\n");
+}

package/dist/auto-reply/auto-reply/reply/reply-inline.js

@@ -0,0 +1,28 @@
+const INLINE_SIMPLE_COMMAND_ALIASES = new Map([
+    ["/help", "/help"],
+    ["/commands", "/commands"],
+    ["/whoami", "/whoami"],
+    ["/id", "/whoami"],
+]);
+const INLINE_SIMPLE_COMMAND_RE = /(?:^|\s)\/(help|commands|whoami|id)(?=$|\s|:)/i;
+const INLINE_STATUS_RE = /(?:^|\s)\/status(?=$|\s|:)(?:\s*:\s*)?/gi;
+export function extractInlineSimpleCommand(body) {
+    if (!body)
+        return null;
+    const match = body.match(INLINE_SIMPLE_COMMAND_RE);
+    if (!match || match.index === undefined)
+        return null;
+    const alias = `/${match[1].toLowerCase()}`;
+    const command = INLINE_SIMPLE_COMMAND_ALIASES.get(alias);
+    if (!command)
+        return null;
+    const cleaned = body.replace(match[0], " ").replace(/\s+/g, " ").trim();
+    return { command, cleaned };
+}
+export function stripInlineStatus(body) {
+    const trimmed = body.trim();
+    if (!trimmed)
+        return { cleaned: "", didStrip: false };
+    const cleaned = trimmed.replace(INLINE_STATUS_RE, " ").replace(/\s+/g, " ").trim();
+    return { cleaned, didStrip: cleaned !== trimmed };
+}

package/dist/auto-reply/auto-reply/reply/reply-payloads.js

@@ -0,0 +1,114 @@
+import { isMessagingToolDuplicate } from "../../agents/pi-embedded-helpers.js";
+import { normalizeTargetForProvider } from "../../infra/outbound/target-normalization.js";
+import { normalizeOptionalAccountId } from "../../routing/account-id.js";
+import { extractReplyToTag } from "./reply-tags.js";
+import { createReplyToModeFilterForChannel } from "./reply-threading.js";
+function resolveReplyThreadingForPayload(params) {
+    const implicitReplyToId = params.implicitReplyToId?.trim() || undefined;
+    const currentMessageId = params.currentMessageId?.trim() || undefined;
+    // 1) Apply implicit reply threading first (replyToMode will strip later if needed).
+    let resolved = params.payload.replyToId || params.payload.replyToCurrent === false || !implicitReplyToId
+        ? params.payload
+        : { ...params.payload, replyToId: implicitReplyToId };
+    // 2) Parse explicit reply tags from text (if present) and clean them.
+    if (typeof resolved.text === "string" && resolved.text.includes("[[")) {
+        const { cleaned, replyToId, replyToCurrent, hasTag } = extractReplyToTag(resolved.text, currentMessageId);
+        resolved = {
+            ...resolved,
+            text: cleaned ? cleaned : undefined,
+            replyToId: replyToId ?? resolved.replyToId,
+            replyToTag: hasTag || resolved.replyToTag,
+            replyToCurrent: replyToCurrent || resolved.replyToCurrent,
+        };
+    }
+    // 3) If replyToCurrent was set out-of-band (e.g. tags already stripped upstream),
+    // ensure replyToId is set to the current message id when available.
+    if (resolved.replyToCurrent && !resolved.replyToId && currentMessageId) {
+        resolved = {
+            ...resolved,
+            replyToId: currentMessageId,
+        };
+    }
+    return resolved;
+}
+// Backward-compatible helper: apply explicit reply tags/directives to a single payload.
+// This intentionally does not apply implicit threading.
+export function applyReplyTagsToPayload(payload, currentMessageId) {
+    return resolveReplyThreadingForPayload({ payload, currentMessageId });
+}
+export function isRenderablePayload(payload) {
+    return Boolean(payload.text ||
+        payload.mediaUrl ||
+        (payload.mediaUrls && payload.mediaUrls.length > 0) ||
+        payload.audioAsVoice ||
+        payload.channelData);
+}
+export function applyReplyThreading(params) {
+    const { payloads, replyToMode, replyToChannel, currentMessageId } = params;
+    const applyReplyToMode = createReplyToModeFilterForChannel(replyToMode, replyToChannel);
+    const implicitReplyToId = currentMessageId?.trim() || undefined;
+    return payloads
+        .map((payload) => resolveReplyThreadingForPayload({ payload, implicitReplyToId, currentMessageId }))
+        .filter(isRenderablePayload)
+        .map(applyReplyToMode);
+}
+export function filterMessagingToolDuplicates(params) {
+    const { payloads, sentTexts } = params;
+    if (sentTexts.length === 0) {
+        return payloads;
+    }
+    return payloads.filter((payload) => !isMessagingToolDuplicate(payload.text ?? "", sentTexts));
+}
+export function filterMessagingToolMediaDuplicates(params) {
+    const { payloads, sentMediaUrls } = params;
+    if (sentMediaUrls.length === 0) {
+        return payloads;
+    }
+    const sentSet = new Set(sentMediaUrls);
+    return payloads.map((payload) => {
+        const mediaUrl = payload.mediaUrl;
+        const mediaUrls = payload.mediaUrls;
+        const stripSingle = mediaUrl && sentSet.has(mediaUrl);
+        const filteredUrls = mediaUrls?.filter((u) => !sentSet.has(u));
+        if (!stripSingle && (!mediaUrls || filteredUrls?.length === mediaUrls.length)) {
+            return payload; // No change
+        }
+        return {
+            ...payload,
+            mediaUrl: stripSingle ? undefined : mediaUrl,
+            mediaUrls: filteredUrls?.length ? filteredUrls : undefined,
+        };
+    });
+}
+export function shouldSuppressMessagingToolReplies(params) {
+    const provider = params.messageProvider?.trim().toLowerCase();
+    if (!provider) {
+        return false;
+    }
+    const originTarget = normalizeTargetForProvider(provider, params.originatingTo);
+    if (!originTarget) {
+        return false;
+    }
+    const originAccount = normalizeOptionalAccountId(params.accountId);
+    const sentTargets = params.messagingToolSentTargets ?? [];
+    if (sentTargets.length === 0) {
+        return false;
+    }
+    return sentTargets.some((target) => {
+        if (!target?.provider) {
+            return false;
+        }
+        if (target.provider.trim().toLowerCase() !== provider) {
+            return false;
+        }
+        const targetKey = normalizeTargetForProvider(provider, target.to);
+        if (!targetKey) {
+            return false;
+        }
+        const targetAccount = normalizeOptionalAccountId(target.accountId);
+        if (originAccount && targetAccount && originAccount !== targetAccount) {
+            return false;
+        }
+        return targetKey === originTarget;
+    });
+}

package/dist/auto-reply/auto-reply/reply/reply-reference.js

@@ -0,0 +1,36 @@
+export function createReplyReferencePlanner(options) {
+    let hasReplied = options.hasReplied ?? false;
+    const allowReference = options.allowReference !== false;
+    const existingId = options.existingId?.trim();
+    const startId = options.startId?.trim();
+    const use = () => {
+        if (!allowReference) {
+            return undefined;
+        }
+        if (options.replyToMode === "off") {
+            return undefined;
+        }
+        const id = existingId ?? startId;
+        if (!id) {
+            return undefined;
+        }
+        if (options.replyToMode === "all") {
+            hasReplied = true;
+            return id;
+        }
+        // "first": only the first reply gets a reference.
+        if (!hasReplied) {
+            hasReplied = true;
+            return id;
+        }
+        return undefined;
+    };
+    const markSent = () => {
+        hasReplied = true;
+    };
+    return {
+        use,
+        markSent,
+        hasReplied: () => hasReplied,
+    };
+}

package/dist/auto-reply/auto-reply/reply/reply-tags.js

@@ -0,0 +1,13 @@
+import { parseInlineDirectives } from "../../utils/directive-tags.js";
+export function extractReplyToTag(text, currentMessageId) {
+    const result = parseInlineDirectives(text, {
+        currentMessageId,
+        stripAudioTag: false,
+    });
+    return {
+        cleaned: result.text,
+        replyToId: result.replyToId,
+        replyToCurrent: result.replyToCurrent,
+        hasTag: result.hasReplyTag,
+    };
+}

package/dist/auto-reply/auto-reply/reply/reply-threading.js

@@ -0,0 +1,41 @@
+import { getChannelDock } from "../../channels/dock.js";
+import { normalizeChannelId } from "../../channels/plugins/index.js";
+export function resolveReplyToMode(cfg, channel, accountId, chatType) {
+    const provider = normalizeChannelId(channel);
+    if (!provider)
+        return "all";
+    const resolved = getChannelDock(provider)?.threading?.resolveReplyToMode?.({
+        cfg,
+        accountId,
+        chatType,
+    });
+    return resolved ?? "all";
+}
+export function createReplyToModeFilter(mode, opts = {}) {
+    let hasThreaded = false;
+    return (payload) => {
+        if (!payload.replyToId)
+            return payload;
+        if (mode === "off") {
+            if (opts.allowTagsWhenOff && payload.replyToTag)
+                return payload;
+            return { ...payload, replyToId: undefined };
+        }
+        if (mode === "all")
+            return payload;
+        if (hasThreaded) {
+            return { ...payload, replyToId: undefined };
+        }
+        hasThreaded = true;
+        return payload;
+    };
+}
+export function createReplyToModeFilterForChannel(mode, channel) {
+    const provider = normalizeChannelId(channel);
+    const allowTagsWhenOff = provider
+        ? Boolean(getChannelDock(provider)?.threading?.allowTagsWhenOff)
+        : false;
+    return createReplyToModeFilter(mode, {
+        allowTagsWhenOff,
+    });
+}