@poolzin/pool-bot 2026.3.25 → 2026.3.26

package/dist/auto-reply/auto-reply/reply/get-reply-run.js

@@ -0,0 +1,297 @@
+import crypto from "node:crypto";
+import { abortEmbeddedPiRun, isEmbeddedPiRunActive, isEmbeddedPiRunStreaming, resolveEmbeddedSessionLane, } from "../../agents/pi-embedded.js";
+import { resolveSessionAuthProfileOverride } from "../../agents/auth-profiles/session-override.js";
+import { resolveGroupSessionKey, resolveSessionFilePath, updateSessionStore, } from "../../config/sessions.js";
+import { logVerbose } from "../../globals.js";
+import { clearCommandLane, getQueueSize } from "../../process/command-queue.js";
+import { normalizeMainKey } from "../../routing/session-key.js";
+import { isReasoningTagProvider } from "../../utils/provider-utils.js";
+import { hasControlCommand } from "../command-detection.js";
+import { buildInboundMediaNote } from "../media-note.js";
+import { formatXHighModelHint, normalizeThinkLevel, supportsXHighThinking, } from "../thinking.js";
+import { SILENT_REPLY_TOKEN } from "../tokens.js";
+import { runReplyAgent } from "./agent-runner.js";
+import { applySessionHints } from "./body.js";
+import { routeReply } from "./route-reply.js";
+import { buildGroupIntro } from "./groups.js";
+import { resolveQueueSettings } from "./queue.js";
+import { ensureSkillSnapshot, prependSystemEvents } from "./session-updates.js";
+import { resolveTypingMode } from "./typing-mode.js";
+import { buildInboundMetaSystemPrompt, buildInboundUserContextPrefix } from "./inbound-meta.js";
+import { appendUntrustedContext } from "./untrusted-context.js";
+const BARE_SESSION_RESET_PROMPT = "A new session was started via /new or /reset. Greet the user in your configured persona, if one is provided. Be yourself - use your defined voice, mannerisms, and mood. Keep it to 1-3 sentences and ask what they want to do. If the runtime model differs from default_model in the system prompt, mention the default model. Do not mention internal steps, files, tools, or reasoning.";
+export async function runPreparedReply(params) {
+    const { ctx, sessionCtx, cfg, agentId, agentDir, agentCfg, sessionCfg, commandAuthorized, command, commandSource, allowTextCommands, directives, defaultActivation, elevatedEnabled, elevatedAllowed, blockStreamingEnabled, blockReplyChunking, resolvedBlockStreamingBreak, modelState, provider, model, perMessageQueueMode, perMessageQueueOptions, typing, opts, defaultProvider, defaultModel, timeoutMs, isNewSession, resetTriggered, systemSent, sessionKey, sessionId, storePath, workspaceDir, sessionStore, } = params;
+    let { sessionEntry, resolvedThinkLevel, resolvedVerboseLevel, resolvedReasoningLevel, resolvedElevatedLevel, execOverrides, abortedLastRun, } = params;
+    let currentSystemSent = systemSent;
+    const isFirstTurnInSession = isNewSession || !currentSystemSent;
+    const isGroupChat = sessionCtx.ChatType === "group";
+    const wasMentioned = ctx.WasMentioned === true;
+    const isHeartbeat = opts?.isHeartbeat === true;
+    const typingMode = resolveTypingMode({
+        configured: sessionCfg?.typingMode ?? agentCfg?.typingMode,
+        isGroupChat,
+        wasMentioned,
+        isHeartbeat,
+    });
+    const shouldInjectGroupIntro = Boolean(isGroupChat && (isFirstTurnInSession || sessionEntry?.groupActivationNeedsSystemIntro));
+    const groupIntro = shouldInjectGroupIntro
+        ? buildGroupIntro({
+            cfg,
+            sessionCtx,
+            sessionEntry,
+            defaultActivation,
+            silentToken: SILENT_REPLY_TOKEN,
+        })
+        : "";
+    const groupSystemPrompt = sessionCtx.GroupSystemPrompt?.trim() ?? "";
+    const inboundMetaPrompt = buildInboundMetaSystemPrompt(isNewSession ? sessionCtx : { ...sessionCtx, ThreadStarterBody: undefined });
+    const extraSystemPrompt = [inboundMetaPrompt, groupIntro, groupSystemPrompt]
+        .filter(Boolean)
+        .join("\n\n");
+    const baseBody = sessionCtx.BodyStripped ?? sessionCtx.Body ?? "";
+    // Use CommandBody/RawBody for bare reset detection (clean message without structural context).
+    const rawBodyTrimmed = (ctx.CommandBody ?? ctx.RawBody ?? ctx.Body ?? "").trim();
+    const baseBodyTrimmedRaw = baseBody.trim();
+    if (allowTextCommands &&
+        (!commandAuthorized || !command.isAuthorizedSender) &&
+        !baseBodyTrimmedRaw &&
+        hasControlCommand(commandSource, cfg)) {
+        typing.cleanup();
+        return undefined;
+    }
+    const isBareNewOrReset = rawBodyTrimmed === "/new" || rawBodyTrimmed === "/reset";
+    const isBareSessionReset = isNewSession &&
+        ((baseBodyTrimmedRaw.length === 0 && rawBodyTrimmed.length > 0) || isBareNewOrReset);
+    const baseBodyFinal = isBareSessionReset ? BARE_SESSION_RESET_PROMPT : baseBody;
+    const inboundUserContext = buildInboundUserContextPrefix(isNewSession ? sessionCtx : { ...sessionCtx, ThreadStarterBody: undefined });
+    const baseBodyForPrompt = isBareSessionReset
+        ? baseBodyFinal
+        : [inboundUserContext, baseBodyFinal].filter(Boolean).join("\n\n");
+    const baseBodyTrimmed = baseBodyForPrompt.trim();
+    if (!baseBodyTrimmed) {
+        await typing.onReplyStart();
+        logVerbose("Inbound body empty after normalization; skipping agent run");
+        typing.cleanup();
+        return {
+            text: "I didn't receive any text in your message. Please resend or add a caption.",
+        };
+    }
+    let prefixedBodyBase = await applySessionHints({
+        baseBody: baseBodyForPrompt,
+        abortedLastRun,
+        sessionEntry,
+        sessionStore,
+        sessionKey,
+        storePath,
+        abortKey: command.abortKey,
+        messageId: sessionCtx.MessageSid,
+    });
+    const isGroupSession = sessionEntry?.chatType === "group" || sessionEntry?.chatType === "channel";
+    const isMainSession = !isGroupSession && sessionKey === normalizeMainKey(sessionCfg?.mainKey);
+    prefixedBodyBase = await prependSystemEvents({
+        cfg,
+        sessionKey,
+        isMainSession,
+        isNewSession,
+        prefixedBodyBase,
+    });
+    prefixedBodyBase = appendUntrustedContext(prefixedBodyBase, sessionCtx.UntrustedContext);
+    const threadStarterBody = ctx.ThreadStarterBody?.trim();
+    const threadStarterNote = isNewSession && threadStarterBody
+        ? `[Thread starter - for context]\n${threadStarterBody}`
+        : undefined;
+    const skillResult = await ensureSkillSnapshot({
+        sessionEntry,
+        sessionStore,
+        sessionKey,
+        storePath,
+        sessionId,
+        isFirstTurnInSession,
+        workspaceDir,
+        cfg,
+        skillFilter: opts?.skillFilter,
+    });
+    sessionEntry = skillResult.sessionEntry ?? sessionEntry;
+    currentSystemSent = skillResult.systemSent;
+    const skillsSnapshot = skillResult.skillsSnapshot;
+    const prefixedBody = [threadStarterNote, prefixedBodyBase].filter(Boolean).join("\n\n");
+    const mediaNote = buildInboundMediaNote(ctx);
+    const mediaReplyHint = mediaNote
+        ? "To send an image back, prefer the message tool (media/path/filePath). If you must inline, use MEDIA:https://example.com/image.jpg (spaces ok, quote if needed) or a safe relative path like MEDIA:./image.jpg. Avoid absolute paths (MEDIA:/...) and ~ paths — they are blocked for security. Keep caption in the text body."
+        : undefined;
+    let prefixedCommandBody = mediaNote
+        ? [mediaNote, mediaReplyHint, prefixedBody ?? ""].filter(Boolean).join("\n").trim()
+        : prefixedBody;
+    if (!resolvedThinkLevel && prefixedCommandBody) {
+        const parts = prefixedCommandBody.split(/\s+/);
+        const maybeLevel = normalizeThinkLevel(parts[0]);
+        if (maybeLevel && (maybeLevel !== "xhigh" || supportsXHighThinking(provider, model))) {
+            resolvedThinkLevel = maybeLevel;
+            prefixedCommandBody = parts.slice(1).join(" ").trim();
+        }
+    }
+    if (!resolvedThinkLevel) {
+        resolvedThinkLevel = await modelState.resolveDefaultThinkingLevel();
+    }
+    if (resolvedThinkLevel === "xhigh" && !supportsXHighThinking(provider, model)) {
+        const explicitThink = directives.hasThinkDirective && directives.thinkLevel !== undefined;
+        if (explicitThink) {
+            typing.cleanup();
+            return {
+                text: `Thinking level "xhigh" is only supported for ${formatXHighModelHint()}. Use /think high or switch to one of those models.`,
+            };
+        }
+        resolvedThinkLevel = "high";
+        if (sessionEntry && sessionStore && sessionKey && sessionEntry.thinkingLevel === "xhigh") {
+            sessionEntry.thinkingLevel = "high";
+            sessionEntry.updatedAt = Date.now();
+            sessionStore[sessionKey] = sessionEntry;
+            if (storePath) {
+                await updateSessionStore(storePath, (store) => {
+                    store[sessionKey] = sessionEntry;
+                });
+            }
+        }
+    }
+    if (resetTriggered && command.isAuthorizedSender) {
+        const channel = ctx.OriginatingChannel || command.channel;
+        const to = ctx.OriginatingTo || command.from || command.to;
+        if (channel && to) {
+            const modelLabel = `${provider}/${model}`;
+            const defaultLabel = `${defaultProvider}/${defaultModel}`;
+            const text = modelLabel === defaultLabel
+                ? `✅ New session started · model: ${modelLabel}`
+                : `✅ New session started · model: ${modelLabel} (default: ${defaultLabel})`;
+            await routeReply({
+                payload: { text },
+                channel,
+                to,
+                sessionKey,
+                accountId: ctx.AccountId,
+                threadId: ctx.MessageThreadId,
+                cfg,
+            });
+        }
+    }
+    const sessionIdFinal = sessionId ?? crypto.randomUUID();
+    const sessionFile = resolveSessionFilePath(sessionIdFinal, sessionEntry);
+    const queueBodyBase = [threadStarterNote, baseBodyFinal].filter(Boolean).join("\n\n");
+    const queueMessageId = sessionCtx.MessageSid?.trim();
+    const queueMessageIdHint = queueMessageId ? `[message_id: ${queueMessageId}]` : "";
+    const queueBodyWithId = queueMessageIdHint
+        ? `${queueBodyBase}\n${queueMessageIdHint}`
+        : queueBodyBase;
+    const queuedBody = mediaNote
+        ? [mediaNote, mediaReplyHint, queueBodyWithId].filter(Boolean).join("\n").trim()
+        : queueBodyWithId;
+    const resolvedQueue = resolveQueueSettings({
+        cfg,
+        channel: sessionCtx.Provider,
+        sessionEntry,
+        inlineMode: perMessageQueueMode,
+        inlineOptions: perMessageQueueOptions,
+    });
+    const sessionLaneKey = resolveEmbeddedSessionLane(sessionKey ?? sessionIdFinal);
+    const laneSize = getQueueSize(sessionLaneKey);
+    if (resolvedQueue.mode === "interrupt" && laneSize > 0) {
+        const cleared = clearCommandLane(sessionLaneKey);
+        const aborted = abortEmbeddedPiRun(sessionIdFinal);
+        logVerbose(`Interrupting ${sessionLaneKey} (cleared ${cleared}, aborted=${aborted})`);
+    }
+    const queueKey = sessionKey ?? sessionIdFinal;
+    const isActive = isEmbeddedPiRunActive(sessionIdFinal);
+    const isStreaming = isEmbeddedPiRunStreaming(sessionIdFinal);
+    const shouldSteer = resolvedQueue.mode === "steer" || resolvedQueue.mode === "steer-backlog";
+    const shouldFollowup = resolvedQueue.mode === "followup" ||
+        resolvedQueue.mode === "collect" ||
+        resolvedQueue.mode === "steer-backlog";
+    const authProfileId = await resolveSessionAuthProfileOverride({
+        cfg,
+        provider,
+        agentDir,
+        sessionEntry,
+        sessionStore,
+        sessionKey,
+        storePath,
+        isNewSession,
+    });
+    const authProfileIdSource = sessionEntry?.authProfileOverrideSource;
+    const followupRun = {
+        prompt: queuedBody,
+        messageId: sessionCtx.MessageSidFull ?? sessionCtx.MessageSid,
+        summaryLine: baseBodyTrimmedRaw,
+        enqueuedAt: Date.now(),
+        // Originating channel for reply routing.
+        originatingChannel: ctx.OriginatingChannel,
+        originatingTo: ctx.OriginatingTo,
+        originatingAccountId: ctx.AccountId,
+        originatingThreadId: ctx.MessageThreadId,
+        originatingChatType: ctx.ChatType,
+        run: {
+            agentId,
+            agentDir,
+            sessionId: sessionIdFinal,
+            sessionKey,
+            messageProvider: sessionCtx.Provider?.trim().toLowerCase() || undefined,
+            agentAccountId: sessionCtx.AccountId,
+            groupId: resolveGroupSessionKey(sessionCtx)?.id ?? undefined,
+            groupChannel: sessionCtx.GroupChannel?.trim() ?? sessionCtx.GroupSubject?.trim(),
+            groupSpace: sessionCtx.GroupSpace?.trim() ?? undefined,
+            senderId: sessionCtx.SenderId?.trim() || undefined,
+            senderName: sessionCtx.SenderName?.trim() || undefined,
+            senderUsername: sessionCtx.SenderUsername?.trim() || undefined,
+            senderE164: sessionCtx.SenderE164?.trim() || undefined,
+            senderIsOwner: command.senderIsOwner,
+            sessionFile,
+            workspaceDir,
+            config: cfg,
+            skillsSnapshot,
+            provider,
+            model,
+            authProfileId,
+            authProfileIdSource,
+            thinkLevel: resolvedThinkLevel,
+            verboseLevel: resolvedVerboseLevel,
+            reasoningLevel: resolvedReasoningLevel,
+            elevatedLevel: resolvedElevatedLevel,
+            execOverrides,
+            bashElevated: {
+                enabled: elevatedEnabled,
+                allowed: elevatedAllowed,
+                defaultLevel: resolvedElevatedLevel ?? "off",
+            },
+            timeoutMs,
+            blockReplyBreak: resolvedBlockStreamingBreak,
+            ownerNumbers: command.ownerList.length > 0 ? command.ownerList : undefined,
+            extraSystemPrompt: extraSystemPrompt || undefined,
+            ...(isReasoningTagProvider(provider) ? { enforceFinalTag: true } : {}),
+        },
+    };
+    return runReplyAgent({
+        commandBody: prefixedCommandBody,
+        followupRun,
+        queueKey,
+        resolvedQueue,
+        shouldSteer,
+        shouldFollowup,
+        isActive,
+        isStreaming,
+        opts,
+        typing,
+        sessionEntry,
+        sessionStore,
+        sessionKey,
+        storePath,
+        defaultModel,
+        agentCfgContextTokens: agentCfg?.contextTokens,
+        resolvedVerboseLevel: resolvedVerboseLevel ?? "off",
+        isNewSession,
+        blockStreamingEnabled,
+        blockReplyChunking,
+        resolvedBlockStreamingBreak,
+        sessionCtx,
+        shouldInjectGroupIntro,
+        typingMode,
+    });
+}

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

@@ -0,0 +1,102 @@
+import { getChannelDock } from "../../channels/dock.js";
+import { getChannelPlugin, normalizeChannelId } from "../../channels/plugins/index.js";
+import { isInternalMessageChannel } from "../../utils/message-channel.js";
+import { normalizeGroupActivation } from "../group-activation.js";
+function extractGroupId(raw) {
+    const trimmed = (raw ?? "").trim();
+    if (!trimmed)
+        return undefined;
+    const parts = trimmed.split(":").filter(Boolean);
+    if (parts.length >= 3 && (parts[1] === "group" || parts[1] === "channel")) {
+        return parts.slice(2).join(":") || undefined;
+    }
+    if (parts.length >= 2 &&
+        parts[0]?.toLowerCase() === "whatsapp" &&
+        trimmed.toLowerCase().includes("@g.us")) {
+        return parts.slice(1).join(":") || undefined;
+    }
+    if (parts.length >= 2 && (parts[0] === "group" || parts[0] === "channel")) {
+        return parts.slice(1).join(":") || undefined;
+    }
+    return trimmed;
+}
+export function resolveGroupRequireMention(params) {
+    const { cfg, ctx, groupResolution } = params;
+    const rawChannel = groupResolution?.channel ?? ctx.Provider?.trim();
+    const channel = normalizeChannelId(rawChannel);
+    if (!channel)
+        return true;
+    const groupId = groupResolution?.id ?? extractGroupId(ctx.From);
+    const groupChannel = ctx.GroupChannel?.trim() ?? ctx.GroupSubject?.trim();
+    const groupSpace = ctx.GroupSpace?.trim();
+    const requireMention = getChannelDock(channel)?.groups?.resolveRequireMention?.({
+        cfg,
+        groupId,
+        groupChannel,
+        groupSpace,
+        accountId: ctx.AccountId,
+    });
+    if (typeof requireMention === "boolean")
+        return requireMention;
+    return true;
+}
+export function defaultGroupActivation(requireMention) {
+    return requireMention === false ? "always" : "mention";
+}
+export function buildGroupIntro(params) {
+    const activation = normalizeGroupActivation(params.sessionEntry?.groupActivation) ?? params.defaultActivation;
+    const subject = params.sessionCtx.GroupSubject?.trim();
+    const members = params.sessionCtx.GroupMembers?.trim();
+    const rawProvider = params.sessionCtx.Provider?.trim();
+    const providerKey = rawProvider?.toLowerCase() ?? "";
+    const providerId = normalizeChannelId(rawProvider);
+    const providerLabel = (() => {
+        if (!providerKey)
+            return "chat";
+        if (isInternalMessageChannel(providerKey))
+            return "WebChat";
+        if (providerId)
+            return getChannelPlugin(providerId)?.meta.label ?? providerId;
+        return `${providerKey.at(0)?.toUpperCase() ?? ""}${providerKey.slice(1)}`;
+    })();
+    const subjectLine = subject
+        ? `You are replying inside the ${providerLabel} group "${subject}".`
+        : `You are replying inside a ${providerLabel} group chat.`;
+    const membersLine = members ? `Group members: ${members}.` : undefined;
+    const activationLine = activation === "always"
+        ? "Activation: always-on (you receive every group message)."
+        : "Activation: trigger-only (you are invoked only when explicitly mentioned; recent context may be included).";
+    const groupId = params.sessionEntry?.groupId ?? extractGroupId(params.sessionCtx.From);
+    const groupChannel = params.sessionCtx.GroupChannel?.trim() ?? subject;
+    const groupSpace = params.sessionCtx.GroupSpace?.trim();
+    const providerIdsLine = providerId
+        ? getChannelDock(providerId)?.groups?.resolveGroupIntroHint?.({
+            cfg: params.cfg,
+            groupId,
+            groupChannel,
+            groupSpace,
+            accountId: params.sessionCtx.AccountId,
+        })
+        : undefined;
+    const silenceLine = activation === "always"
+        ? `If no response is needed, reply with exactly "${params.silentToken}" (and nothing else) so Poolbot stays silent. Do not add any other words, punctuation, tags, markdown/code blocks, or explanations.`
+        : undefined;
+    const cautionLine = activation === "always"
+        ? "Be extremely selective: reply only when directly addressed or clearly helpful. Otherwise stay silent."
+        : undefined;
+    const lurkLine = "Be a good group participant: mostly lurk and follow the conversation; reply only when directly addressed or you can add clear value. Emoji reactions are welcome when available.";
+    const styleLine = "Write like a human. Avoid Markdown tables. Don't type literal \\n sequences; use real line breaks sparingly.";
+    return [
+        subjectLine,
+        membersLine,
+        activationLine,
+        providerIdsLine,
+        silenceLine,
+        cautionLine,
+        lurkLine,
+        styleLine,
+    ]
+        .filter(Boolean)
+        .join(" ")
+        .concat(" Address the specific sender noted in the message context.");
+}

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

@@ -0,0 +1,129 @@
+import { resolveAgentConfig } from "../../agents/agent-scope.js";
+import { getChannelDock } from "../../channels/dock.js";
+import { normalizeChannelId } from "../../channels/plugins/index.js";
+import { escapeRegExp } from "../../utils.js";
+function deriveMentionPatterns(identity) {
+    const patterns = [];
+    const name = identity?.name?.trim();
+    if (name) {
+        const parts = name.split(/\s+/).filter(Boolean).map(escapeRegExp);
+        const re = parts.length ? parts.join(String.raw `\s+`) : escapeRegExp(name);
+        patterns.push(String.raw `\b@?${re}\b`);
+    }
+    const emoji = identity?.emoji?.trim();
+    if (emoji) {
+        patterns.push(escapeRegExp(emoji));
+    }
+    return patterns;
+}
+const BACKSPACE_CHAR = "\u0008";
+export const CURRENT_MESSAGE_MARKER = "[Current message - respond to this]";
+function normalizeMentionPattern(pattern) {
+    if (!pattern.includes(BACKSPACE_CHAR)) {
+        return pattern;
+    }
+    return pattern.split(BACKSPACE_CHAR).join("\\b");
+}
+function normalizeMentionPatterns(patterns) {
+    return patterns.map(normalizeMentionPattern);
+}
+function resolveMentionPatterns(cfg, agentId) {
+    if (!cfg) {
+        return [];
+    }
+    const agentConfig = agentId ? resolveAgentConfig(cfg, agentId) : undefined;
+    const agentGroupChat = agentConfig?.groupChat;
+    if (agentGroupChat && Object.hasOwn(agentGroupChat, "mentionPatterns")) {
+        return agentGroupChat.mentionPatterns ?? [];
+    }
+    const globalGroupChat = cfg.messages?.groupChat;
+    if (globalGroupChat && Object.hasOwn(globalGroupChat, "mentionPatterns")) {
+        return globalGroupChat.mentionPatterns ?? [];
+    }
+    const derived = deriveMentionPatterns(agentConfig?.identity);
+    return derived.length > 0 ? derived : [];
+}
+export function buildMentionRegexes(cfg, agentId) {
+    const patterns = normalizeMentionPatterns(resolveMentionPatterns(cfg, agentId));
+    return patterns
+        .map((pattern) => {
+        try {
+            return new RegExp(pattern, "i");
+        }
+        catch {
+            return null;
+        }
+    })
+        .filter((value) => Boolean(value));
+}
+export function normalizeMentionText(text) {
+    return (text ?? "").replace(/[\u200b-\u200f\u202a-\u202e\u2060-\u206f]/g, "").toLowerCase();
+}
+export function matchesMentionPatterns(text, mentionRegexes) {
+    if (mentionRegexes.length === 0) {
+        return false;
+    }
+    const cleaned = normalizeMentionText(text ?? "");
+    if (!cleaned) {
+        return false;
+    }
+    return mentionRegexes.some((re) => re.test(cleaned));
+}
+export function matchesMentionWithExplicit(params) {
+    const cleaned = normalizeMentionText(params.text ?? "");
+    const explicit = params.explicit?.isExplicitlyMentioned === true;
+    const explicitAvailable = params.explicit?.canResolveExplicit === true;
+    const hasAnyMention = params.explicit?.hasAnyMention === true;
+    // Check transcript if text is empty and transcript is provided
+    const transcriptCleaned = params.transcript ? normalizeMentionText(params.transcript) : "";
+    const textToCheck = cleaned || transcriptCleaned;
+    if (hasAnyMention && explicitAvailable) {
+        return explicit || params.mentionRegexes.some((re) => re.test(textToCheck));
+    }
+    if (!textToCheck) {
+        return explicit;
+    }
+    return explicit || params.mentionRegexes.some((re) => re.test(textToCheck));
+}
+export function stripStructuralPrefixes(text) {
+    // Ignore wrapper labels, timestamps, and sender prefixes so directive-only
+    // detection still works in group batches that include history/context.
+    const afterMarker = text.includes(CURRENT_MESSAGE_MARKER)
+        ? text.slice(text.indexOf(CURRENT_MESSAGE_MARKER) + CURRENT_MESSAGE_MARKER.length).trimStart()
+        : text;
+    return afterMarker
+        .replace(/\[[^\]]+\]\s*/g, "")
+        .replace(/^[ \t]*[A-Za-z0-9+()\-_. ]+:\s*/gm, "")
+        .replace(/\\n/g, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+export function stripMentions(text, ctx, cfg, agentId) {
+    let result = text;
+    const providerId = ctx.Provider ? normalizeChannelId(ctx.Provider) : null;
+    const providerMentions = providerId ? getChannelDock(providerId)?.mentions : undefined;
+    const patterns = normalizeMentionPatterns([
+        ...resolveMentionPatterns(cfg, agentId),
+        ...(providerMentions?.stripPatterns?.({ ctx, cfg, agentId }) ?? []),
+    ]);
+    for (const p of patterns) {
+        try {
+            const re = new RegExp(p, "gi");
+            result = result.replace(re, " ");
+        }
+        catch {
+            // ignore invalid regex
+        }
+    }
+    if (providerMentions?.stripMentions) {
+        result = providerMentions.stripMentions({
+            text: result,
+            ctx,
+            cfg,
+            agentId,
+        });
+    }
+    // Generic mention patterns like @123456789 or plain digits
+    result = result.replace(/@[0-9+]{5,}/g, " ");
+    return result.replace(/\s+/g, " ").trim();
+}

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

@@ -0,0 +1,92 @@
+import { logVerbose } from "../../globals.js";
+import { SILENT_REPLY_TOKEN } from "../tokens.js";
+import { createBlockReplyPayloadKey } from "./block-reply-pipeline.js";
+import { parseReplyDirectives } from "./reply-directives.js";
+import { applyReplyTagsToPayload, isRenderablePayload } from "./reply-payloads.js";
+export function normalizeReplyPayloadDirectives(params) {
+    const parseMode = params.parseMode ?? "always";
+    const silentToken = params.silentToken ?? SILENT_REPLY_TOKEN;
+    const sourceText = params.payload.text ?? "";
+    const shouldParse = parseMode === "always" ||
+        (parseMode === "auto" &&
+            (sourceText.includes("[[") ||
+                sourceText.includes("MEDIA:") ||
+                sourceText.includes(silentToken)));
+    const parsed = shouldParse
+        ? parseReplyDirectives(sourceText, {
+            currentMessageId: params.currentMessageId,
+            silentToken,
+        })
+        : undefined;
+    let text = parsed ? parsed.text || undefined : params.payload.text || undefined;
+    if (params.trimLeadingWhitespace && text) {
+        text = text.trimStart() || undefined;
+    }
+    const mediaUrls = params.payload.mediaUrls ?? parsed?.mediaUrls;
+    const mediaUrl = params.payload.mediaUrl ?? parsed?.mediaUrl ?? mediaUrls?.[0];
+    return {
+        payload: {
+            ...params.payload,
+            text,
+            mediaUrls,
+            mediaUrl,
+            replyToId: params.payload.replyToId ?? parsed?.replyToId,
+            replyToTag: params.payload.replyToTag || parsed?.replyToTag,
+            replyToCurrent: params.payload.replyToCurrent || parsed?.replyToCurrent,
+            audioAsVoice: Boolean(params.payload.audioAsVoice || parsed?.audioAsVoice),
+        },
+        isSilent: parsed?.isSilent ?? false,
+    };
+}
+const hasRenderableMedia = (payload) => Boolean(payload.mediaUrl) || (payload.mediaUrls?.length ?? 0) > 0;
+export function createBlockReplyDeliveryHandler(params) {
+    return async (payload) => {
+        const { text, skip } = params.normalizeStreamingText(payload);
+        if (skip && !hasRenderableMedia(payload)) {
+            return;
+        }
+        const taggedPayload = applyReplyTagsToPayload({
+            ...payload,
+            text,
+            mediaUrl: payload.mediaUrl ?? payload.mediaUrls?.[0],
+            replyToId: payload.replyToId ??
+                (payload.replyToCurrent === false ? undefined : params.currentMessageId),
+        }, params.currentMessageId);
+        // Let through payloads with audioAsVoice flag even if empty (need to track it).
+        if (!isRenderablePayload(taggedPayload) && !payload.audioAsVoice) {
+            return;
+        }
+        const normalized = normalizeReplyPayloadDirectives({
+            payload: taggedPayload,
+            currentMessageId: params.currentMessageId,
+            silentToken: SILENT_REPLY_TOKEN,
+            trimLeadingWhitespace: true,
+            parseMode: "auto",
+        });
+        const blockPayload = params.applyReplyToMode(normalized.payload);
+        const blockHasMedia = hasRenderableMedia(blockPayload);
+        // Skip empty payloads unless they have audioAsVoice flag (need to track it).
+        if (!blockPayload.text && !blockHasMedia && !blockPayload.audioAsVoice) {
+            return;
+        }
+        if (normalized.isSilent && !blockHasMedia) {
+            return;
+        }
+        if (blockPayload.text) {
+            void params.typingSignals.signalTextDelta(blockPayload.text).catch((err) => {
+                logVerbose(`block reply typing signal failed: ${String(err)}`);
+            });
+        }
+        // Use pipeline if available (block streaming enabled), otherwise send directly.
+        if (params.blockStreamingEnabled && params.blockReplyPipeline) {
+            params.blockReplyPipeline.enqueue(blockPayload);
+        }
+        else if (params.blockStreamingEnabled) {
+            // Send directly when flushing before tool execution (no pipeline but streaming enabled).
+            // Track sent key to avoid duplicate in final payloads.
+            params.directlySentBlockKeys.add(createBlockReplyPayloadKey(blockPayload));
+            await params.onBlockReply(blockPayload);
+        }
+        // When streaming is disabled entirely, blocks are accumulated in final text instead.
+    };
+}

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

@@ -0,0 +1,30 @@
+import { splitMediaFromOutput } from "../../media/parse.js";
+import { parseInlineDirectives } from "../../utils/directive-tags.js";
+import { isSilentReplyText, SILENT_REPLY_TOKEN } from "../tokens.js";
+export function parseReplyDirectives(raw, options = {}) {
+    const split = splitMediaFromOutput(raw);
+    let text = split.text ?? "";
+    const replyParsed = parseInlineDirectives(text, {
+        currentMessageId: options.currentMessageId,
+        stripAudioTag: false,
+        stripReplyTags: true,
+    });
+    if (replyParsed.hasReplyTag) {
+        text = replyParsed.text;
+    }
+    const silentToken = options.silentToken ?? SILENT_REPLY_TOKEN;
+    const isSilent = isSilentReplyText(text, silentToken);
+    if (isSilent) {
+        text = "";
+    }
+    return {
+        text,
+        mediaUrls: split.mediaUrls,
+        mediaUrl: split.mediaUrl,
+        replyToId: replyParsed.replyToId,
+        replyToCurrent: replyParsed.replyToCurrent,
+        replyToTag: replyParsed.hasReplyTag,
+        audioAsVoice: split.audioAsVoice,
+        isSilent,
+    };
+}