@poolzin/pool-bot 2026.3.25 → 2026.3.27

package/dist/auto-reply/auto-reply/reply/followup-runner.js

@@ -0,0 +1,227 @@
+import crypto from "node:crypto";
+import { resolveAgentModelFallbacksOverride } from "../../agents/agent-scope.js";
+import { lookupContextTokens } from "../../agents/context.js";
+import { DEFAULT_CONTEXT_TOKENS } from "../../agents/defaults.js";
+import { runWithModelFallback } from "../../agents/model-fallback.js";
+import { runEmbeddedPiAgent } from "../../agents/pi-embedded.js";
+import { resolveAgentIdFromSessionKey } from "../../config/sessions.js";
+import { logVerbose } from "../../globals.js";
+import { registerAgentRunContext } from "../../infra/agent-events.js";
+import { defaultRuntime } from "../../runtime.js";
+import { stripHeartbeatToken } from "../heartbeat.js";
+import { isSilentReplyText, SILENT_REPLY_TOKEN } from "../tokens.js";
+import { applyReplyThreading, filterMessagingToolDuplicates, shouldSuppressMessagingToolReplies, } from "./reply-payloads.js";
+import { resolveReplyToMode } from "./reply-threading.js";
+import { isRoutableChannel, routeReply } from "./route-reply.js";
+import { persistSessionUsageUpdate } from "./session-usage.js";
+import { incrementCompactionCount } from "./session-updates.js";
+import { createTypingSignaler } from "./typing-mode.js";
+export function createFollowupRunner(params) {
+    const { opts, typing, typingMode, sessionEntry, sessionStore, sessionKey, storePath, defaultModel, agentCfgContextTokens, } = params;
+    const typingSignals = createTypingSignaler({
+        typing,
+        mode: typingMode,
+        isHeartbeat: opts?.isHeartbeat === true,
+    });
+    /**
+     * Sends followup payloads, routing to the originating channel if set.
+     *
+     * When originatingChannel/originatingTo are set on the queued run,
+     * replies are routed directly to that provider instead of using the
+     * session's current dispatcher. This ensures replies go back to
+     * where the message originated.
+     */
+    const sendFollowupPayloads = async (payloads, queued) => {
+        // Check if we should route to originating channel.
+        const { originatingChannel, originatingTo } = queued;
+        const shouldRouteToOriginating = isRoutableChannel(originatingChannel) && originatingTo;
+        if (!shouldRouteToOriginating && !opts?.onBlockReply) {
+            logVerbose("followup queue: no onBlockReply handler; dropping payloads");
+            return;
+        }
+        for (const payload of payloads) {
+            if (!payload?.text && !payload?.mediaUrl && !payload?.mediaUrls?.length) {
+                continue;
+            }
+            if (isSilentReplyText(payload.text, SILENT_REPLY_TOKEN) &&
+                !payload.mediaUrl &&
+                !payload.mediaUrls?.length) {
+                continue;
+            }
+            await typingSignals.signalTextDelta(payload.text);
+            // Route to originating channel if set, otherwise fall back to dispatcher.
+            if (shouldRouteToOriginating) {
+                const result = await routeReply({
+                    payload,
+                    channel: originatingChannel,
+                    to: originatingTo,
+                    sessionKey: queued.run.sessionKey,
+                    accountId: queued.originatingAccountId,
+                    threadId: queued.originatingThreadId,
+                    cfg: queued.run.config,
+                });
+                if (!result.ok) {
+                    // Log error and fall back to dispatcher if available.
+                    const errorMsg = result.error ?? "unknown error";
+                    logVerbose(`followup queue: route-reply failed: ${errorMsg}`);
+                    // Fallback: try the dispatcher if routing failed.
+                    if (opts?.onBlockReply) {
+                        await opts.onBlockReply(payload);
+                    }
+                }
+            }
+            else if (opts?.onBlockReply) {
+                await opts.onBlockReply(payload);
+            }
+        }
+    };
+    return async (queued) => {
+        try {
+            const runId = crypto.randomUUID();
+            if (queued.run.sessionKey) {
+                registerAgentRunContext(runId, {
+                    sessionKey: queued.run.sessionKey,
+                    verboseLevel: queued.run.verboseLevel,
+                });
+            }
+            let autoCompactionCompleted = false;
+            let runResult;
+            let fallbackProvider = queued.run.provider;
+            let fallbackModel = queued.run.model;
+            try {
+                const fallbackResult = await runWithModelFallback({
+                    cfg: queued.run.config,
+                    provider: queued.run.provider,
+                    model: queued.run.model,
+                    agentDir: queued.run.agentDir,
+                    fallbacksOverride: resolveAgentModelFallbacksOverride(queued.run.config, resolveAgentIdFromSessionKey(queued.run.sessionKey)),
+                    run: (provider, model) => {
+                        const authProfileId = provider === queued.run.provider ? queued.run.authProfileId : undefined;
+                        return runEmbeddedPiAgent({
+                            sessionId: queued.run.sessionId,
+                            sessionKey: queued.run.sessionKey,
+                            messageProvider: queued.run.messageProvider,
+                            agentAccountId: queued.run.agentAccountId,
+                            messageTo: queued.originatingTo,
+                            messageThreadId: queued.originatingThreadId,
+                            groupId: queued.run.groupId,
+                            groupChannel: queued.run.groupChannel,
+                            groupSpace: queued.run.groupSpace,
+                            senderId: queued.run.senderId,
+                            senderName: queued.run.senderName,
+                            senderUsername: queued.run.senderUsername,
+                            senderE164: queued.run.senderE164,
+                            senderIsOwner: queued.run.senderIsOwner,
+                            sessionFile: queued.run.sessionFile,
+                            workspaceDir: queued.run.workspaceDir,
+                            config: queued.run.config,
+                            skillsSnapshot: queued.run.skillsSnapshot,
+                            prompt: queued.prompt,
+                            extraSystemPrompt: queued.run.extraSystemPrompt,
+                            ownerNumbers: queued.run.ownerNumbers,
+                            enforceFinalTag: queued.run.enforceFinalTag,
+                            provider,
+                            model,
+                            authProfileId,
+                            authProfileIdSource: authProfileId ? queued.run.authProfileIdSource : undefined,
+                            thinkLevel: queued.run.thinkLevel,
+                            verboseLevel: queued.run.verboseLevel,
+                            reasoningLevel: queued.run.reasoningLevel,
+                            execOverrides: queued.run.execOverrides,
+                            bashElevated: queued.run.bashElevated,
+                            timeoutMs: queued.run.timeoutMs,
+                            runId,
+                            blockReplyBreak: queued.run.blockReplyBreak,
+                            onAgentEvent: (evt) => {
+                                if (evt.stream !== "compaction")
+                                    return;
+                                const phase = typeof evt.data.phase === "string" ? evt.data.phase : "";
+                                const willRetry = Boolean(evt.data.willRetry);
+                                if (phase === "end" && !willRetry) {
+                                    autoCompactionCompleted = true;
+                                }
+                            },
+                        });
+                    },
+                });
+                runResult = fallbackResult.result;
+                fallbackProvider = fallbackResult.provider;
+                fallbackModel = fallbackResult.model;
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                defaultRuntime.error?.(`Followup agent failed before reply: ${message}`);
+                return;
+            }
+            if (storePath && sessionKey) {
+                const usage = runResult.meta.agentMeta?.usage;
+                const modelUsed = runResult.meta.agentMeta?.model ?? fallbackModel ?? defaultModel;
+                const contextTokensUsed = agentCfgContextTokens ??
+                    lookupContextTokens(modelUsed) ??
+                    sessionEntry?.contextTokens ??
+                    DEFAULT_CONTEXT_TOKENS;
+                await persistSessionUsageUpdate({
+                    storePath,
+                    sessionKey,
+                    usage,
+                    modelUsed,
+                    providerUsed: fallbackProvider,
+                    contextTokensUsed,
+                    logLabel: "followup",
+                });
+            }
+            const payloadArray = runResult.payloads ?? [];
+            if (payloadArray.length === 0)
+                return;
+            const sanitizedPayloads = payloadArray.flatMap((payload) => {
+                const text = payload.text;
+                if (!text || !text.includes("HEARTBEAT_OK"))
+                    return [payload];
+                const stripped = stripHeartbeatToken(text, { mode: "message" });
+                const hasMedia = Boolean(payload.mediaUrl) || (payload.mediaUrls?.length ?? 0) > 0;
+                if (stripped.shouldSkip && !hasMedia)
+                    return [];
+                return [{ ...payload, text: stripped.text }];
+            });
+            const replyToChannel = queued.originatingChannel ??
+                queued.run.messageProvider?.toLowerCase();
+            const replyToMode = resolveReplyToMode(queued.run.config, replyToChannel, queued.originatingAccountId, queued.originatingChatType);
+            const replyTaggedPayloads = applyReplyThreading({
+                payloads: sanitizedPayloads,
+                replyToMode,
+                replyToChannel,
+            });
+            const dedupedPayloads = filterMessagingToolDuplicates({
+                payloads: replyTaggedPayloads,
+                sentTexts: runResult.messagingToolSentTexts ?? [],
+            });
+            const suppressMessagingToolReplies = shouldSuppressMessagingToolReplies({
+                messageProvider: queued.run.messageProvider,
+                messagingToolSentTargets: runResult.messagingToolSentTargets,
+                originatingTo: queued.originatingTo,
+                accountId: queued.run.agentAccountId,
+            });
+            const finalPayloads = suppressMessagingToolReplies ? [] : dedupedPayloads;
+            if (finalPayloads.length === 0)
+                return;
+            if (autoCompactionCompleted) {
+                const count = await incrementCompactionCount({
+                    sessionEntry,
+                    sessionStore,
+                    sessionKey,
+                    storePath,
+                });
+                if (queued.run.verboseLevel && queued.run.verboseLevel !== "off") {
+                    const suffix = typeof count === "number" ? ` (count ${count})` : "";
+                    finalPayloads.unshift({
+                        text: `🧹 Auto-compaction complete${suffix}.`,
+                    });
+                }
+            }
+            await sendFollowupPayloads(finalPayloads, queued);
+        }
+        finally {
+            typing.markRunComplete();
+        }
+    };
+}

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

@@ -0,0 +1,201 @@
+import { buildStatusReply } from "./commands.js";
+import { applyInlineDirectivesFastLane, handleDirectiveOnly, isDirectiveOnly, persistInlineDirectives, } from "./directive-handling.js";
+export async function applyInlineDirectiveOverrides(params) {
+    const { ctx, cfg, agentId, agentDir, agentCfg, sessionEntry, sessionStore, sessionKey, storePath, sessionScope, isGroup, allowTextCommands, command, messageProviderKey, elevatedEnabled, elevatedAllowed, elevatedFailures, defaultProvider, defaultModel, aliasIndex, modelState, initialModelLabel, formatModelSwitchEvent, resolvedElevatedLevel, defaultActivation, typing, effectiveModelDirective, } = params;
+    let { directives } = params;
+    let { provider, model } = params;
+    let { contextTokens } = params;
+    let directiveAck;
+    if (!command.isAuthorizedSender) {
+        directives = {
+            ...directives,
+            hasThinkDirective: false,
+            hasVerboseDirective: false,
+            hasReasoningDirective: false,
+            hasElevatedDirective: false,
+            hasExecDirective: false,
+            execHost: undefined,
+            execSecurity: undefined,
+            execAsk: undefined,
+            execNode: undefined,
+            rawExecHost: undefined,
+            rawExecSecurity: undefined,
+            rawExecAsk: undefined,
+            rawExecNode: undefined,
+            hasExecOptions: false,
+            invalidExecHost: false,
+            invalidExecSecurity: false,
+            invalidExecAsk: false,
+            invalidExecNode: false,
+            hasStatusDirective: false,
+            hasModelDirective: false,
+            hasQueueDirective: false,
+            queueReset: false,
+        };
+    }
+    if (isDirectiveOnly({
+        directives,
+        cleanedBody: directives.cleaned,
+        ctx,
+        cfg,
+        agentId,
+        isGroup,
+    })) {
+        if (!command.isAuthorizedSender) {
+            typing.cleanup();
+            return { kind: "reply", reply: undefined };
+        }
+        const resolvedDefaultThinkLevel = sessionEntry?.thinkingLevel ??
+            agentCfg?.thinkingDefault ??
+            (await modelState.resolveDefaultThinkingLevel());
+        const currentThinkLevel = resolvedDefaultThinkLevel;
+        const currentVerboseLevel = sessionEntry?.verboseLevel ??
+            agentCfg?.verboseDefault;
+        const currentReasoningLevel = sessionEntry?.reasoningLevel ?? "off";
+        const currentElevatedLevel = sessionEntry?.elevatedLevel ??
+            agentCfg?.elevatedDefault;
+        const directiveReply = await handleDirectiveOnly({
+            cfg,
+            directives,
+            sessionEntry,
+            sessionStore,
+            sessionKey,
+            storePath,
+            elevatedEnabled,
+            elevatedAllowed,
+            elevatedFailures,
+            messageProviderKey,
+            defaultProvider,
+            defaultModel,
+            aliasIndex,
+            allowedModelKeys: modelState.allowedModelKeys,
+            allowedModelCatalog: modelState.allowedModelCatalog,
+            resetModelOverride: modelState.resetModelOverride,
+            provider,
+            model,
+            initialModelLabel,
+            formatModelSwitchEvent,
+            currentThinkLevel,
+            currentVerboseLevel,
+            currentReasoningLevel,
+            currentElevatedLevel,
+        });
+        let statusReply;
+        if (directives.hasStatusDirective && allowTextCommands && command.isAuthorizedSender) {
+            statusReply = await buildStatusReply({
+                cfg,
+                command,
+                sessionEntry,
+                sessionKey,
+                sessionScope,
+                provider,
+                model,
+                contextTokens,
+                resolvedThinkLevel: resolvedDefaultThinkLevel,
+                resolvedVerboseLevel: (currentVerboseLevel ?? "off"),
+                resolvedReasoningLevel: (currentReasoningLevel ?? "off"),
+                resolvedElevatedLevel,
+                resolveDefaultThinkingLevel: async () => resolvedDefaultThinkLevel,
+                isGroup,
+                defaultGroupActivation: defaultActivation,
+                mediaDecisions: ctx.MediaUnderstandingDecisions,
+            });
+        }
+        typing.cleanup();
+        if (statusReply?.text && directiveReply?.text) {
+            return {
+                kind: "reply",
+                reply: { text: `${directiveReply.text}\n${statusReply.text}` },
+            };
+        }
+        return { kind: "reply", reply: statusReply ?? directiveReply };
+    }
+    const hasAnyDirective = directives.hasThinkDirective ||
+        directives.hasVerboseDirective ||
+        directives.hasReasoningDirective ||
+        directives.hasElevatedDirective ||
+        directives.hasExecDirective ||
+        directives.hasModelDirective ||
+        directives.hasQueueDirective ||
+        directives.hasStatusDirective;
+    if (hasAnyDirective && command.isAuthorizedSender) {
+        const fastLane = await applyInlineDirectivesFastLane({
+            directives,
+            commandAuthorized: command.isAuthorizedSender,
+            ctx,
+            cfg,
+            agentId,
+            isGroup,
+            sessionEntry,
+            sessionStore,
+            sessionKey,
+            storePath,
+            elevatedEnabled,
+            elevatedAllowed,
+            elevatedFailures,
+            messageProviderKey,
+            defaultProvider,
+            defaultModel,
+            aliasIndex,
+            allowedModelKeys: modelState.allowedModelKeys,
+            allowedModelCatalog: modelState.allowedModelCatalog,
+            resetModelOverride: modelState.resetModelOverride,
+            provider,
+            model,
+            initialModelLabel,
+            formatModelSwitchEvent,
+            agentCfg,
+            modelState: {
+                resolveDefaultThinkingLevel: modelState.resolveDefaultThinkingLevel,
+                allowedModelKeys: modelState.allowedModelKeys,
+                allowedModelCatalog: modelState.allowedModelCatalog,
+                resetModelOverride: modelState.resetModelOverride,
+            },
+        });
+        directiveAck = fastLane.directiveAck;
+        provider = fastLane.provider;
+        model = fastLane.model;
+    }
+    const persisted = await persistInlineDirectives({
+        directives,
+        effectiveModelDirective,
+        cfg,
+        agentDir,
+        sessionEntry,
+        sessionStore,
+        sessionKey,
+        storePath,
+        elevatedEnabled,
+        elevatedAllowed,
+        defaultProvider,
+        defaultModel,
+        aliasIndex,
+        allowedModelKeys: modelState.allowedModelKeys,
+        provider,
+        model,
+        initialModelLabel,
+        formatModelSwitchEvent,
+        agentCfg,
+    });
+    provider = persisted.provider;
+    model = persisted.model;
+    contextTokens = persisted.contextTokens;
+    const perMessageQueueMode = directives.hasQueueDirective && !directives.queueReset ? directives.queueMode : undefined;
+    const perMessageQueueOptions = directives.hasQueueDirective && !directives.queueReset
+        ? {
+            debounceMs: directives.debounceMs,
+            cap: directives.cap,
+            dropPolicy: directives.dropPolicy,
+        }
+        : undefined;
+    return {
+        kind: "continue",
+        directives,
+        provider,
+        model,
+        contextTokens,
+        directiveAck,
+        perMessageQueueMode,
+        perMessageQueueOptions,
+    };
+}

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

@@ -0,0 +1,54 @@
+const CLEARED_EXEC_FIELDS = {
+    hasExecDirective: false,
+    execHost: undefined,
+    execSecurity: undefined,
+    execAsk: undefined,
+    execNode: undefined,
+    rawExecHost: undefined,
+    rawExecSecurity: undefined,
+    rawExecAsk: undefined,
+    rawExecNode: undefined,
+    hasExecOptions: false,
+    invalidExecHost: false,
+    invalidExecSecurity: false,
+    invalidExecAsk: false,
+    invalidExecNode: false,
+};
+export function clearInlineDirectives(cleaned) {
+    return {
+        cleaned,
+        hasThinkDirective: false,
+        thinkLevel: undefined,
+        rawThinkLevel: undefined,
+        hasVerboseDirective: false,
+        verboseLevel: undefined,
+        rawVerboseLevel: undefined,
+        hasReasoningDirective: false,
+        reasoningLevel: undefined,
+        rawReasoningLevel: undefined,
+        hasElevatedDirective: false,
+        elevatedLevel: undefined,
+        rawElevatedLevel: undefined,
+        ...CLEARED_EXEC_FIELDS,
+        hasStatusDirective: false,
+        hasModelDirective: false,
+        rawModelDirective: undefined,
+        hasQueueDirective: false,
+        queueMode: undefined,
+        queueReset: false,
+        rawQueueMode: undefined,
+        debounceMs: undefined,
+        cap: undefined,
+        dropPolicy: undefined,
+        rawDebounce: undefined,
+        rawCap: undefined,
+        rawDrop: undefined,
+        hasQueueOptions: false,
+    };
+}
+export function clearExecInlineDirectives(directives) {
+    return {
+        ...directives,
+        ...CLEARED_EXEC_FIELDS,
+    };
+}