@poolzin/pool-bot 2026.3.25 → 2026.3.26

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

@@ -0,0 +1,332 @@
+import { resolveSandboxRuntimeStatus } from "../../agents/sandbox.js";
+import { listChatCommands, shouldHandleTextCommands } from "../commands-registry.js";
+import { listSkillCommandsForWorkspace } from "../skill-commands.js";
+import { resolveBlockStreamingChunking } from "./block-streaming.js";
+import { buildCommandContext } from "./commands.js";
+import { parseInlineDirectives } from "./directive-handling.js";
+import { applyInlineDirectiveOverrides } from "./get-reply-directives-apply.js";
+import { clearExecInlineDirectives, clearInlineDirectives } from "./get-reply-directives-utils.js";
+import { defaultGroupActivation, resolveGroupRequireMention } from "./groups.js";
+import { CURRENT_MESSAGE_MARKER, stripMentions, stripStructuralPrefixes } from "./mentions.js";
+import { createModelSelectionState, resolveContextTokens } from "./model-selection.js";
+import { formatElevatedUnavailableMessage, resolveElevatedPermissions } from "./reply-elevated.js";
+import { stripInlineStatus } from "./reply-inline.js";
+function resolveExecOverrides(params) {
+    const host = params.directives.execHost ?? params.sessionEntry?.execHost;
+    const security = params.directives.execSecurity ??
+        params.sessionEntry?.execSecurity;
+    const ask = params.directives.execAsk ?? params.sessionEntry?.execAsk;
+    const node = params.directives.execNode ?? params.sessionEntry?.execNode;
+    if (!host && !security && !ask && !node) {
+        return undefined;
+    }
+    return { host, security, ask, node };
+}
+export async function resolveReplyDirectives(params) {
+    const { ctx, cfg, agentId, agentCfg, agentDir, workspaceDir, sessionCtx, sessionEntry, sessionStore, sessionKey, storePath, sessionScope, groupResolution, isGroup, triggerBodyNormalized, commandAuthorized, defaultProvider, defaultModel, provider: initialProvider, model: initialModel, hasResolvedHeartbeatModelOverride, typing, opts, skillFilter, } = params;
+    let provider = initialProvider;
+    let model = initialModel;
+    // Prefer CommandBody/RawBody (clean message without structural context) for directive parsing.
+    // Keep `Body`/`BodyStripped` as the best-available prompt text (may include context).
+    const commandSource = sessionCtx.BodyForCommands ??
+        sessionCtx.CommandBody ??
+        sessionCtx.RawBody ??
+        sessionCtx.Transcript ??
+        sessionCtx.BodyStripped ??
+        sessionCtx.Body ??
+        ctx.BodyForCommands ??
+        ctx.CommandBody ??
+        ctx.RawBody ??
+        "";
+    const promptSource = sessionCtx.BodyForAgent ?? sessionCtx.BodyStripped ?? sessionCtx.Body ?? "";
+    const commandText = commandSource || promptSource;
+    const command = buildCommandContext({
+        ctx,
+        cfg,
+        agentId,
+        sessionKey,
+        isGroup,
+        triggerBodyNormalized,
+        commandAuthorized,
+    });
+    const allowTextCommands = shouldHandleTextCommands({
+        cfg,
+        surface: command.surface,
+        commandSource: ctx.CommandSource,
+    });
+    const reservedCommands = new Set(listChatCommands().flatMap((cmd) => cmd.textAliases.map((a) => a.replace(/^\//, "").toLowerCase())));
+    const rawAliases = Object.values(cfg.agents?.defaults?.models ?? {})
+        .map((entry) => entry.alias?.trim())
+        .filter((alias) => Boolean(alias))
+        .filter((alias) => !reservedCommands.has(alias.toLowerCase()));
+    // Only load workspace skill commands when we actually need them to filter aliases.
+    // This avoids scanning skills for messages that only use inline directives like /think:/verbose:.
+    const skillCommands = allowTextCommands && rawAliases.length > 0
+        ? listSkillCommandsForWorkspace({
+            workspaceDir,
+            cfg,
+            skillFilter,
+        })
+        : [];
+    for (const command of skillCommands) {
+        reservedCommands.add(command.name.toLowerCase());
+    }
+    const configuredAliases = rawAliases.filter((alias) => !reservedCommands.has(alias.toLowerCase()));
+    const allowStatusDirective = allowTextCommands && command.isAuthorizedSender;
+    let parsedDirectives = parseInlineDirectives(commandText, {
+        modelAliases: configuredAliases,
+        allowStatusDirective,
+    });
+    const hasInlineStatus = parsedDirectives.hasStatusDirective && parsedDirectives.cleaned.trim().length > 0;
+    if (hasInlineStatus) {
+        parsedDirectives = {
+            ...parsedDirectives,
+            hasStatusDirective: false,
+        };
+    }
+    if (isGroup && ctx.WasMentioned !== true && parsedDirectives.hasElevatedDirective) {
+        if (parsedDirectives.elevatedLevel !== "off") {
+            parsedDirectives = {
+                ...parsedDirectives,
+                hasElevatedDirective: false,
+                elevatedLevel: undefined,
+                rawElevatedLevel: undefined,
+            };
+        }
+    }
+    if (isGroup && ctx.WasMentioned !== true && parsedDirectives.hasExecDirective) {
+        if (parsedDirectives.execSecurity !== "deny") {
+            parsedDirectives = clearExecInlineDirectives(parsedDirectives);
+        }
+    }
+    const hasInlineDirective = parsedDirectives.hasThinkDirective ||
+        parsedDirectives.hasVerboseDirective ||
+        parsedDirectives.hasReasoningDirective ||
+        parsedDirectives.hasElevatedDirective ||
+        parsedDirectives.hasExecDirective ||
+        parsedDirectives.hasModelDirective ||
+        parsedDirectives.hasQueueDirective;
+    if (hasInlineDirective) {
+        const stripped = stripStructuralPrefixes(parsedDirectives.cleaned);
+        const noMentions = isGroup ? stripMentions(stripped, ctx, cfg, agentId) : stripped;
+        if (noMentions.trim().length > 0) {
+            const directiveOnlyCheck = parseInlineDirectives(noMentions, {
+                modelAliases: configuredAliases,
+            });
+            if (directiveOnlyCheck.cleaned.trim().length > 0) {
+                const allowInlineStatus = parsedDirectives.hasStatusDirective && allowTextCommands && command.isAuthorizedSender;
+                parsedDirectives = allowInlineStatus
+                    ? {
+                        ...clearInlineDirectives(parsedDirectives.cleaned),
+                        hasStatusDirective: true,
+                    }
+                    : clearInlineDirectives(parsedDirectives.cleaned);
+            }
+        }
+    }
+    let directives = commandAuthorized
+        ? parsedDirectives
+        : {
+            ...parsedDirectives,
+            hasThinkDirective: false,
+            hasVerboseDirective: false,
+            hasReasoningDirective: false,
+            hasStatusDirective: false,
+            hasModelDirective: false,
+            hasQueueDirective: false,
+            queueReset: false,
+        };
+    const existingBody = sessionCtx.BodyStripped ?? sessionCtx.Body ?? "";
+    let cleanedBody = (() => {
+        if (!existingBody) {
+            return parsedDirectives.cleaned;
+        }
+        if (!sessionCtx.CommandBody && !sessionCtx.RawBody) {
+            return parseInlineDirectives(existingBody, {
+                modelAliases: configuredAliases,
+                allowStatusDirective,
+            }).cleaned;
+        }
+        const markerIndex = existingBody.indexOf(CURRENT_MESSAGE_MARKER);
+        if (markerIndex < 0) {
+            return parseInlineDirectives(existingBody, {
+                modelAliases: configuredAliases,
+                allowStatusDirective,
+            }).cleaned;
+        }
+        const head = existingBody.slice(0, markerIndex + CURRENT_MESSAGE_MARKER.length);
+        const tail = existingBody.slice(markerIndex + CURRENT_MESSAGE_MARKER.length);
+        const cleanedTail = parseInlineDirectives(tail, {
+            modelAliases: configuredAliases,
+            allowStatusDirective,
+        }).cleaned;
+        return `${head}${cleanedTail}`;
+    })();
+    if (allowStatusDirective) {
+        cleanedBody = stripInlineStatus(cleanedBody).cleaned;
+    }
+    sessionCtx.BodyForAgent = cleanedBody;
+    sessionCtx.Body = cleanedBody;
+    sessionCtx.BodyStripped = cleanedBody;
+    const messageProviderKey = sessionCtx.Provider?.trim().toLowerCase() ?? ctx.Provider?.trim().toLowerCase() ?? "";
+    const elevated = resolveElevatedPermissions({
+        cfg,
+        agentId,
+        ctx,
+        provider: messageProviderKey,
+    });
+    const elevatedEnabled = elevated.enabled;
+    const elevatedAllowed = elevated.allowed;
+    const elevatedFailures = elevated.failures;
+    if (directives.hasElevatedDirective && (!elevatedEnabled || !elevatedAllowed)) {
+        typing.cleanup();
+        const runtimeSandboxed = resolveSandboxRuntimeStatus({
+            cfg,
+            sessionKey: ctx.SessionKey,
+        }).sandboxed;
+        return {
+            kind: "reply",
+            reply: {
+                text: formatElevatedUnavailableMessage({
+                    runtimeSandboxed,
+                    failures: elevatedFailures,
+                    sessionKey: ctx.SessionKey,
+                }),
+            },
+        };
+    }
+    const requireMention = resolveGroupRequireMention({
+        cfg,
+        ctx: sessionCtx,
+        groupResolution,
+    });
+    const defaultActivation = defaultGroupActivation(requireMention);
+    const resolvedThinkLevel = directives.thinkLevel ??
+        sessionEntry?.thinkingLevel ??
+        agentCfg?.thinkingDefault;
+    const resolvedVerboseLevel = directives.verboseLevel ??
+        sessionEntry?.verboseLevel ??
+        agentCfg?.verboseDefault;
+    const resolvedReasoningLevel = directives.reasoningLevel ??
+        sessionEntry?.reasoningLevel ??
+        "off";
+    const resolvedElevatedLevel = elevatedAllowed
+        ? (directives.elevatedLevel ??
+            sessionEntry?.elevatedLevel ??
+            agentCfg?.elevatedDefault ??
+            "on")
+        : "off";
+    const resolvedBlockStreaming = opts?.disableBlockStreaming === true
+        ? "off"
+        : opts?.disableBlockStreaming === false
+            ? "on"
+            : agentCfg?.blockStreamingDefault === "on"
+                ? "on"
+                : "off";
+    const resolvedBlockStreamingBreak = agentCfg?.blockStreamingBreak === "message_end" ? "message_end" : "text_end";
+    const blockStreamingEnabled = resolvedBlockStreaming === "on" && opts?.disableBlockStreaming !== true;
+    const blockReplyChunking = blockStreamingEnabled
+        ? resolveBlockStreamingChunking(cfg, sessionCtx.Provider, sessionCtx.AccountId)
+        : undefined;
+    const modelState = await createModelSelectionState({
+        cfg,
+        agentCfg,
+        sessionEntry,
+        sessionStore,
+        sessionKey,
+        parentSessionKey: ctx.ParentSessionKey,
+        storePath,
+        defaultProvider,
+        defaultModel,
+        provider,
+        model,
+        hasModelDirective: directives.hasModelDirective,
+        hasResolvedHeartbeatModelOverride,
+    });
+    provider = modelState.provider;
+    model = modelState.model;
+    let contextTokens = resolveContextTokens({
+        agentCfg,
+        model,
+    });
+    const initialModelLabel = `${provider}/${model}`;
+    const formatModelSwitchEvent = (label, alias) => alias ? `Model switched to ${alias} (${label}).` : `Model switched to ${label}.`;
+    const isModelListAlias = directives.hasModelDirective &&
+        ["status", "list"].includes(directives.rawModelDirective?.trim().toLowerCase() ?? "");
+    const effectiveModelDirective = isModelListAlias ? undefined : directives.rawModelDirective;
+    const inlineStatusRequested = hasInlineStatus && allowTextCommands && command.isAuthorizedSender;
+    const applyResult = await applyInlineDirectiveOverrides({
+        ctx,
+        cfg,
+        agentId,
+        agentDir,
+        agentCfg,
+        sessionEntry,
+        sessionStore,
+        sessionKey,
+        storePath,
+        sessionScope,
+        isGroup,
+        allowTextCommands,
+        command,
+        directives,
+        messageProviderKey,
+        elevatedEnabled,
+        elevatedAllowed,
+        elevatedFailures,
+        defaultProvider,
+        defaultModel,
+        aliasIndex: params.aliasIndex,
+        provider,
+        model,
+        modelState,
+        initialModelLabel,
+        formatModelSwitchEvent,
+        resolvedElevatedLevel,
+        defaultActivation: () => defaultActivation,
+        contextTokens,
+        effectiveModelDirective,
+        typing,
+    });
+    if (applyResult.kind === "reply") {
+        return { kind: "reply", reply: applyResult.reply };
+    }
+    directives = applyResult.directives;
+    provider = applyResult.provider;
+    model = applyResult.model;
+    contextTokens = applyResult.contextTokens;
+    const { directiveAck, perMessageQueueMode, perMessageQueueOptions } = applyResult;
+    const execOverrides = resolveExecOverrides({ directives, sessionEntry });
+    return {
+        kind: "continue",
+        result: {
+            commandSource: commandText,
+            command,
+            allowTextCommands,
+            skillCommands,
+            directives,
+            cleanedBody,
+            messageProviderKey,
+            elevatedEnabled,
+            elevatedAllowed,
+            elevatedFailures,
+            defaultActivation,
+            resolvedThinkLevel,
+            resolvedVerboseLevel,
+            resolvedReasoningLevel,
+            resolvedElevatedLevel,
+            execOverrides,
+            blockStreamingEnabled,
+            blockReplyChunking,
+            resolvedBlockStreamingBreak,
+            provider,
+            model,
+            modelState,
+            contextTokens,
+            inlineStatusRequested,
+            directiveAck,
+            perMessageQueueMode,
+            perMessageQueueOptions,
+        },
+    };
+}

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

@@ -0,0 +1,258 @@
+import { getChannelDock } from "../../channels/dock.js";
+import { getAbortMemory } from "./abort.js";
+import { buildStatusReply, handleCommands } from "./commands.js";
+import { isDirectiveOnly } from "./directive-handling.js";
+import { extractInlineSimpleCommand } from "./reply-inline.js";
+import { listSkillCommandsForWorkspace, resolveSkillCommandInvocation } from "../skill-commands.js";
+import { logVerbose } from "../../globals.js";
+import { createPoolBotTools } from "../../agents/poolbot-tools.js";
+import { resolveGatewayMessageChannel } from "../../utils/message-channel.js";
+function extractTextFromToolResult(result) {
+    if (!result || typeof result !== "object")
+        return null;
+    const content = result.content;
+    if (typeof content === "string") {
+        const trimmed = content.trim();
+        return trimmed ? trimmed : null;
+    }
+    if (!Array.isArray(content))
+        return null;
+    const parts = [];
+    for (const block of content) {
+        if (!block || typeof block !== "object")
+            continue;
+        const rec = block;
+        if (rec.type === "text" && typeof rec.text === "string") {
+            parts.push(rec.text);
+        }
+    }
+    const out = parts.join("");
+    const trimmed = out.trim();
+    return trimmed ? trimmed : null;
+}
+export async function handleInlineActions(params) {
+    const { ctx, sessionCtx, cfg, agentId, agentDir, sessionEntry, previousSessionEntry, sessionStore, sessionKey, storePath, sessionScope, workspaceDir, isGroup, opts, typing, allowTextCommands, inlineStatusRequested, command, directives: initialDirectives, cleanedBody: initialCleanedBody, elevatedEnabled, elevatedAllowed, elevatedFailures, defaultActivation, resolvedThinkLevel, resolvedVerboseLevel, resolvedReasoningLevel, resolvedElevatedLevel, resolveDefaultThinkingLevel, provider, model, contextTokens, directiveAck, abortedLastRun: initialAbortedLastRun, skillFilter, } = params;
+    let directives = initialDirectives;
+    let cleanedBody = initialCleanedBody;
+    const shouldLoadSkillCommands = command.commandBodyNormalized.startsWith("/");
+    const skillCommands = shouldLoadSkillCommands && params.skillCommands
+        ? params.skillCommands
+        : shouldLoadSkillCommands
+            ? listSkillCommandsForWorkspace({
+                workspaceDir,
+                cfg,
+                skillFilter,
+            })
+            : [];
+    const skillInvocation = allowTextCommands && skillCommands.length > 0
+        ? resolveSkillCommandInvocation({
+            commandBodyNormalized: command.commandBodyNormalized,
+            skillCommands,
+        })
+        : null;
+    if (skillInvocation) {
+        if (!command.isAuthorizedSender) {
+            logVerbose(`Ignoring /${skillInvocation.command.name} from unauthorized sender: ${command.senderId || "<unknown>"}`);
+            typing.cleanup();
+            return { kind: "reply", reply: undefined };
+        }
+        const dispatch = skillInvocation.command.dispatch;
+        if (dispatch?.kind === "tool") {
+            const rawArgs = (skillInvocation.args ?? "").trim();
+            const channel = resolveGatewayMessageChannel(ctx.Surface) ??
+                resolveGatewayMessageChannel(ctx.Provider) ??
+                undefined;
+            const tools = createPoolBotTools({
+                agentSessionKey: sessionKey,
+                agentChannel: channel,
+                agentAccountId: ctx.AccountId,
+                agentTo: ctx.OriginatingTo ?? ctx.To,
+                agentThreadId: ctx.MessageThreadId ?? undefined,
+                agentDir,
+                workspaceDir,
+                config: cfg,
+            });
+            const tool = tools.find((candidate) => candidate.name === dispatch.toolName);
+            if (!tool) {
+                typing.cleanup();
+                return { kind: "reply", reply: { text: `❌ Tool not available: ${dispatch.toolName}` } };
+            }
+            const toolCallId = `cmd_${Date.now()}_${Math.random().toString(16).slice(2)}`;
+            try {
+                const result = await tool.execute(toolCallId, {
+                    command: rawArgs,
+                    commandName: skillInvocation.command.name,
+                    skillName: skillInvocation.command.skillName,
+                });
+                const text = extractTextFromToolResult(result) ?? "✅ Done.";
+                typing.cleanup();
+                return { kind: "reply", reply: { text } };
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                typing.cleanup();
+                return { kind: "reply", reply: { text: `❌ ${message}` } };
+            }
+        }
+        const promptParts = [
+            `Use the "${skillInvocation.command.skillName}" skill for this request.`,
+            skillInvocation.args ? `User input:\n${skillInvocation.args}` : null,
+        ].filter((entry) => Boolean(entry));
+        const rewrittenBody = promptParts.join("\n\n");
+        ctx.Body = rewrittenBody;
+        ctx.BodyForAgent = rewrittenBody;
+        sessionCtx.Body = rewrittenBody;
+        sessionCtx.BodyForAgent = rewrittenBody;
+        sessionCtx.BodyStripped = rewrittenBody;
+        cleanedBody = rewrittenBody;
+    }
+    const sendInlineReply = async (reply) => {
+        if (!reply)
+            return;
+        if (!opts?.onBlockReply)
+            return;
+        await opts.onBlockReply(reply);
+    };
+    const inlineCommand = allowTextCommands && command.isAuthorizedSender
+        ? extractInlineSimpleCommand(cleanedBody)
+        : null;
+    if (inlineCommand) {
+        cleanedBody = inlineCommand.cleaned;
+        sessionCtx.Body = cleanedBody;
+        sessionCtx.BodyForAgent = cleanedBody;
+        sessionCtx.BodyStripped = cleanedBody;
+    }
+    const handleInlineStatus = !isDirectiveOnly({
+        directives,
+        cleanedBody: directives.cleaned,
+        ctx,
+        cfg,
+        agentId,
+        isGroup,
+    }) && inlineStatusRequested;
+    if (handleInlineStatus) {
+        const inlineStatusReply = await buildStatusReply({
+            cfg,
+            command,
+            sessionEntry,
+            sessionKey,
+            parentSessionKey: ctx.ParentSessionKey,
+            sessionScope,
+            provider,
+            model,
+            contextTokens,
+            resolvedThinkLevel,
+            resolvedVerboseLevel: resolvedVerboseLevel ?? "off",
+            resolvedReasoningLevel,
+            resolvedElevatedLevel,
+            resolveDefaultThinkingLevel,
+            isGroup,
+            defaultGroupActivation: defaultActivation,
+            mediaDecisions: ctx.MediaUnderstandingDecisions,
+        });
+        await sendInlineReply(inlineStatusReply);
+        directives = { ...directives, hasStatusDirective: false };
+    }
+    if (inlineCommand) {
+        const inlineCommandContext = {
+            ...command,
+            rawBodyNormalized: inlineCommand.command,
+            commandBodyNormalized: inlineCommand.command,
+        };
+        const inlineResult = await handleCommands({
+            ctx,
+            cfg,
+            command: inlineCommandContext,
+            agentId,
+            directives,
+            elevated: {
+                enabled: elevatedEnabled,
+                allowed: elevatedAllowed,
+                failures: elevatedFailures,
+            },
+            sessionEntry,
+            previousSessionEntry,
+            sessionStore,
+            sessionKey,
+            storePath,
+            sessionScope,
+            workspaceDir,
+            defaultGroupActivation: defaultActivation,
+            resolvedThinkLevel,
+            resolvedVerboseLevel: resolvedVerboseLevel ?? "off",
+            resolvedReasoningLevel,
+            resolvedElevatedLevel,
+            resolveDefaultThinkingLevel,
+            provider,
+            model,
+            contextTokens,
+            isGroup,
+            skillCommands,
+        });
+        if (inlineResult.reply) {
+            if (!inlineCommand.cleaned) {
+                typing.cleanup();
+                return { kind: "reply", reply: inlineResult.reply };
+            }
+            await sendInlineReply(inlineResult.reply);
+        }
+    }
+    if (directiveAck) {
+        await sendInlineReply(directiveAck);
+    }
+    const isEmptyConfig = Object.keys(cfg).length === 0;
+    const skipWhenConfigEmpty = command.channelId
+        ? Boolean(getChannelDock(command.channelId)?.commands?.skipWhenConfigEmpty)
+        : false;
+    if (skipWhenConfigEmpty &&
+        isEmptyConfig &&
+        command.from &&
+        command.to &&
+        command.from !== command.to) {
+        typing.cleanup();
+        return { kind: "reply", reply: undefined };
+    }
+    let abortedLastRun = initialAbortedLastRun;
+    if (!sessionEntry && command.abortKey) {
+        abortedLastRun = getAbortMemory(command.abortKey) ?? false;
+    }
+    const commandResult = await handleCommands({
+        ctx,
+        cfg,
+        command,
+        agentId,
+        directives,
+        elevated: {
+            enabled: elevatedEnabled,
+            allowed: elevatedAllowed,
+            failures: elevatedFailures,
+        },
+        sessionEntry,
+        previousSessionEntry,
+        sessionStore,
+        sessionKey,
+        storePath,
+        sessionScope,
+        workspaceDir,
+        defaultGroupActivation: defaultActivation,
+        resolvedThinkLevel,
+        resolvedVerboseLevel: resolvedVerboseLevel ?? "off",
+        resolvedReasoningLevel,
+        resolvedElevatedLevel,
+        resolveDefaultThinkingLevel,
+        provider,
+        model,
+        contextTokens,
+        isGroup,
+        skillCommands,
+    });
+    if (!commandResult.shouldContinue) {
+        typing.cleanup();
+        return { kind: "reply", reply: commandResult.reply };
+    }
+    return {
+        kind: "continue",
+        directives,
+        abortedLastRun,
+    };
+}