@poolzin/pool-bot 2026.1.39 → 2026.2.1

package/dist/agents/tools/discord-actions-presence.js

@@ -0,0 +1,78 @@
+import { getGateway } from "../../discord/monitor/gateway-registry.js";
+import { jsonResult, readStringParam } from "./common.js";
+const ACTIVITY_TYPE_MAP = {
+    playing: 0,
+    streaming: 1,
+    listening: 2,
+    watching: 3,
+    custom: 4,
+    competing: 5,
+};
+const VALID_STATUSES = new Set(["online", "dnd", "idle", "invisible"]);
+export async function handleDiscordPresenceAction(action, params, isActionEnabled) {
+    if (action !== "setPresence") {
+        throw new Error(`Unknown presence action: ${action}`);
+    }
+    if (!isActionEnabled("presence", false)) {
+        throw new Error("Discord presence changes are disabled.");
+    }
+    const accountId = readStringParam(params, "accountId");
+    const gateway = getGateway(accountId);
+    if (!gateway) {
+        throw new Error(`Discord gateway not available${accountId ? ` for account "${accountId}"` : ""}. The bot may not be connected.`);
+    }
+    if (!gateway.isConnected) {
+        throw new Error(`Discord gateway is not connected${accountId ? ` for account "${accountId}"` : ""}.`);
+    }
+    const statusRaw = readStringParam(params, "status") ?? "online";
+    if (!VALID_STATUSES.has(statusRaw)) {
+        throw new Error(`Invalid status "${statusRaw}". Must be one of: ${[...VALID_STATUSES].join(", ")}`);
+    }
+    const status = statusRaw;
+    const activityTypeRaw = readStringParam(params, "activityType");
+    const activityName = readStringParam(params, "activityName");
+    const activities = [];
+    if (activityTypeRaw || activityName) {
+        if (!activityTypeRaw) {
+            throw new Error("activityType is required when activityName is provided. " +
+                `Valid types: ${Object.keys(ACTIVITY_TYPE_MAP).join(", ")}`);
+        }
+        const typeNum = ACTIVITY_TYPE_MAP[activityTypeRaw.toLowerCase()];
+        if (typeNum === undefined) {
+            throw new Error(`Invalid activityType "${activityTypeRaw}". Must be one of: ${Object.keys(ACTIVITY_TYPE_MAP).join(", ")}`);
+        }
+        const activity = {
+            name: activityName ?? "",
+            type: typeNum,
+        };
+        // Streaming URL (Twitch/YouTube). May not render for bots but is the correct payload shape.
+        if (typeNum === 1) {
+            const url = readStringParam(params, "activityUrl");
+            if (url) {
+                activity.url = url;
+            }
+        }
+        const state = readStringParam(params, "activityState");
+        if (state) {
+            activity.state = state;
+        }
+        activities.push(activity);
+    }
+    const presenceData = {
+        since: null,
+        activities,
+        status,
+        afk: false,
+    };
+    gateway.updatePresence(presenceData);
+    return jsonResult({
+        ok: true,
+        status,
+        activities: activities.map((a) => ({
+            type: a.type,
+            name: a.name,
+            ...(a.url ? { url: a.url } : {}),
+            ...(a.state ? { state: a.state } : {}),
+        })),
+    });
+}

package/dist/agents/tools/image-tool.js

@@ -11,7 +11,7 @@ import { minimaxUnderstandImage } from "../minimax-vlm.js";
 import { getApiKeyForModel, requireApiKey, resolveEnvApiKey } from "../model-auth.js";
 import { runWithImageModelFallback } from "../model-fallback.js";
 import { resolveConfiguredModelRef } from "../model-selection.js";
-import { ensureMoltbotModelsJson } from "../models-config.js";
+import { ensurePoolbotModelsJson } from "../models-config.js";
 import { assertSandboxPath } from "../sandbox-paths.js";
 import { coerceImageAssistantText, coerceImageModelConfig, decodeDataUrl, resolveProviderVisionModelFromConfig, } from "./image-tool.helpers.js";
 const DEFAULT_PROMPT = "Describe the image.";
@@ -187,7 +187,7 @@ async function runImagePrompt(params) {
             },
         }
         : undefined;
-    await ensureMoltbotModelsJson(effectiveCfg, params.agentDir);
+    await ensurePoolbotModelsJson(effectiveCfg, params.agentDir);
     const authStorage = discoverAuthStorage(params.agentDir);
     const modelRegistry = discoverModels(authStorage, params.agentDir);
     const result = await runWithImageModelFallback({

package/dist/agents/tools/memory-tool.js

@@ -1,5 +1,7 @@
 import { Type } from "@sinclair/typebox";
+import { resolveMemoryBackendConfig } from "../../memory/backend-config.js";
 import { getMemorySearchManager } from "../../memory/index.js";
+import { parseAgentSessionKey } from "../../routing/session-key.js";
 import { resolveSessionAgentId } from "../agent-scope.js";
 import { resolveMemorySearchConfig } from "../memory-search.js";
 import { jsonResult, readNumberParam, readStringParam } from "./common.js";
@@ -15,14 +17,16 @@ const MemoryGetSchema = Type.Object({
 });
 export function createMemorySearchTool(options) {
     const cfg = options.config;
-    if (!cfg)
+    if (!cfg) {
         return null;
+    }
     const agentId = resolveSessionAgentId({
         sessionKey: options.agentSessionKey,
         config: cfg,
     });
-    if (!resolveMemorySearchConfig(cfg, agentId))
+    if (!resolveMemorySearchConfig(cfg, agentId)) {
         return null;
+    }
     return {
         label: "Memory Search",
         name: "memory_search",
@@ -40,17 +44,28 @@ export function createMemorySearchTool(options) {
                 return jsonResult({ results: [], disabled: true, error });
             }
             try {
-                const results = await manager.search(query, {
+                const citationsMode = resolveMemoryCitationsMode(cfg);
+                const includeCitations = shouldIncludeCitations({
+                    mode: citationsMode,
+                    sessionKey: options.agentSessionKey,
+                });
+                const rawResults = await manager.search(query, {
                     maxResults,
                     minScore,
                     sessionKey: options.agentSessionKey,
                 });
                 const status = manager.status();
+                const decorated = decorateCitations(rawResults, includeCitations);
+                const resolved = resolveMemoryBackendConfig({ cfg, agentId });
+                const results = status.backend === "qmd"
+                    ? clampResultsByInjectedChars(decorated, resolved.qmd?.limits.maxInjectedChars)
+                    : decorated;
                 return jsonResult({
                     results,
                     provider: status.provider,
                     model: status.model,
                     fallback: status.fallback,
+                    citations: citationsMode,
                 });
             }
             catch (err) {
@@ -62,14 +77,16 @@ export function createMemorySearchTool(options) {
 }
 export function createMemoryGetTool(options) {
     const cfg = options.config;
-    if (!cfg)
+    if (!cfg) {
         return null;
+    }
     const agentId = resolveSessionAgentId({
         sessionKey: options.agentSessionKey,
         config: cfg,
     });
-    if (!resolveMemorySearchConfig(cfg, agentId))
+    if (!resolveMemorySearchConfig(cfg, agentId)) {
         return null;
+    }
     return {
         label: "Memory Get",
         name: "memory_get",
@@ -101,3 +118,74 @@ export function createMemoryGetTool(options) {
         },
     };
 }
+function resolveMemoryCitationsMode(cfg) {
+    const mode = cfg.memory?.citations;
+    if (mode === "on" || mode === "off" || mode === "auto") {
+        return mode;
+    }
+    return "auto";
+}
+function decorateCitations(results, include) {
+    if (!include) {
+        return results.map((entry) => ({ ...entry, citation: undefined }));
+    }
+    return results.map((entry) => {
+        const citation = formatCitation(entry);
+        const snippet = `${entry.snippet.trim()}\n\nSource: ${citation}`;
+        return { ...entry, citation, snippet };
+    });
+}
+function formatCitation(entry) {
+    const lineRange = entry.startLine === entry.endLine
+        ? `#L${entry.startLine}`
+        : `#L${entry.startLine}-L${entry.endLine}`;
+    return `${entry.path}${lineRange}`;
+}
+function clampResultsByInjectedChars(results, budget) {
+    if (!budget || budget <= 0) {
+        return results;
+    }
+    let remaining = budget;
+    const clamped = [];
+    for (const entry of results) {
+        if (remaining <= 0) {
+            break;
+        }
+        const snippet = entry.snippet ?? "";
+        if (snippet.length <= remaining) {
+            clamped.push(entry);
+            remaining -= snippet.length;
+        }
+        else {
+            const trimmed = snippet.slice(0, Math.max(0, remaining));
+            clamped.push({ ...entry, snippet: trimmed });
+            break;
+        }
+    }
+    return clamped;
+}
+function shouldIncludeCitations(params) {
+    if (params.mode === "on") {
+        return true;
+    }
+    if (params.mode === "off") {
+        return false;
+    }
+    // auto: show citations in direct chats; suppress in groups/channels by default.
+    const chatType = deriveChatTypeFromSessionKey(params.sessionKey);
+    return chatType === "direct";
+}
+function deriveChatTypeFromSessionKey(sessionKey) {
+    const parsed = parseAgentSessionKey(sessionKey);
+    if (!parsed?.rest) {
+        return "direct";
+    }
+    const tokens = new Set(parsed.rest.toLowerCase().split(":").filter(Boolean));
+    if (tokens.has("channel")) {
+        return "channel";
+    }
+    if (tokens.has("group")) {
+        return "group";
+    }
+    return "direct";
+}

package/dist/agents/tools/message-tool.js

@@ -11,8 +11,20 @@ import { normalizeAccountId } from "../../routing/session-key.js";
 import { channelTargetSchema, channelTargetsSchema, stringEnum } from "../schema/typebox.js";
 import { listChannelSupportedActions } from "../channel-tools.js";
 import { normalizeMessageChannel } from "../../utils/message-channel.js";
+import { stripReasoningTagsFromText } from "../../shared/text/reasoning-tags.js";
 import { jsonResult, readNumberParam, readStringParam } from "./common.js";
 const AllMessageActions = CHANNEL_MESSAGE_ACTION_NAMES;
+const EXPLICIT_TARGET_ACTIONS = new Set([
+    "send",
+    "sendWithEffect",
+    "sendAttachment",
+    "reply",
+    "thread-reply",
+    "broadcast",
+]);
+function actionNeedsExplicitTarget(action) {
+    return EXPLICIT_TARGET_ACTIONS.has(action);
+}
 function buildRoutingSchema() {
     return {
         channel: Type.Optional(Type.String()),
@@ -29,7 +41,9 @@ function buildSendSchema(options) {
             description: "Message effect name/id for sendWithEffect (e.g., invisible ink).",
         })),
         effect: Type.Optional(Type.String({ description: "Alias for effectId (e.g., invisible-ink, balloons)." })),
-        media: Type.Optional(Type.String()),
+        media: Type.Optional(Type.String({
+            description: "Media URL or local path. data: URLs are not supported here, use buffer.",
+        })),
         filename: Type.Optional(Type.String()),
         buffer: Type.Optional(Type.String({
             description: "Base64 payload for attachments (optionally a data: URL).",
@@ -45,6 +59,7 @@ function buildSendSchema(options) {
         silent: Type.Optional(Type.Boolean()),
         bestEffort: Type.Optional(Type.Boolean()),
         gifPlayback: Type.Optional(Type.Boolean()),
+        quoteText: Type.Optional(Type.String({ description: "Quote text for Telegram reply_parameters" })),
         buttons: Type.Optional(Type.Array(Type.Array(Type.Object({
             text: Type.String(),
             callback_data: Type.String(),
@@ -159,6 +174,23 @@ function buildChannelManagementSchema() {
         })),
     };
 }
+function buildPresenceSchema() {
+    return {
+        activityType: Type.Optional(Type.String({
+            description: "Activity type: playing, streaming, listening, watching, competing, custom.",
+        })),
+        activityName: Type.Optional(Type.String({
+            description: "Activity name shown in sidebar (e.g. 'with fire'). Ignored for custom type.",
+        })),
+        activityUrl: Type.Optional(Type.String({
+            description: "Streaming URL (Twitch or YouTube). Only used with streaming type; may not render for bots.",
+        })),
+        activityState: Type.Optional(Type.String({
+            description: "State text. For custom type this is the status text; for others it shows in the flyout.",
+        })),
+        status: Type.Optional(Type.String({ description: "Bot status: online, dnd, idle, invisible." })),
+    };
+}
 function buildMessageToolSchemaProps(options) {
     return {
         ...buildRoutingSchema(),
@@ -173,6 +205,7 @@ function buildMessageToolSchemaProps(options) {
         ...buildModerationSchema(),
         ...buildGatewaySchema(),
         ...buildChannelManagementSchema(),
+        ...buildPresenceSchema(),
     };
 }
 function buildMessageToolSchemaFromActions(actions, options) {
@@ -266,11 +299,31 @@ export function createMessageTool(options) {
                 err.name = "AbortError";
                 throw err;
             }
-            const params = args;
+            // Shallow-copy so we don't mutate the original event args (used for logging/dedup).
+            const params = { ...args };
+            // Strip reasoning tags from text fields — models may include <think>…</think>
+            // in tool arguments, and the messaging tool send path has no other tag filtering.
+            for (const field of ["text", "content", "message", "caption"]) {
+                if (typeof params[field] === "string") {
+                    params[field] = stripReasoningTagsFromText(params[field]);
+                }
+            }
             const cfg = options?.config ?? loadConfig();
             const action = readStringParam(params, "action", {
                 required: true,
             });
+            // Enforce explicit target when required (e.g. cron/hook-initiated runs).
+            const requireExplicitTarget = options?.requireExplicitTarget === true;
+            if (requireExplicitTarget && actionNeedsExplicitTarget(action)) {
+                const explicitTarget = (typeof params.target === "string" && params.target.trim().length > 0) ||
+                    (typeof params.to === "string" && params.to.trim().length > 0) ||
+                    (typeof params.channelId === "string" && params.channelId.trim().length > 0) ||
+                    (Array.isArray(params.targets) &&
+                        params.targets.some((value) => typeof value === "string" && value.trim().length > 0));
+                if (!explicitTarget) {
+                    throw new Error("Explicit message target required for this run. Provide target/targets (and channel when needed).");
+                }
+            }
             const accountId = readStringParam(params, "accountId") ?? agentAccountId;
             if (accountId) {
                 params.accountId = accountId;
@@ -309,6 +362,7 @@ export function createMessageTool(options) {
                 agentId: options?.agentSessionKey
                     ? resolveSessionAgentId({ sessionKey: options.agentSessionKey, config: cfg })
                     : undefined,
+                sandboxRoot: options?.sandboxRoot,
                 abortSignal: signal,
             });
             const toolResult = getToolResult(result);

package/dist/agents/tools/sessions-history-tool.js

@@ -1,7 +1,9 @@
 import { Type } from "@sinclair/typebox";
 import { loadConfig } from "../../config/config.js";
 import { callGateway } from "../../gateway/call.js";
+import { capArrayByJsonBytes } from "../../gateway/session-utils.fs.js";
 import { isSubagentSessionKey, resolveAgentIdFromSessionKey } from "../../routing/session-key.js";
+import { truncateUtf16Safe } from "../../utils.js";
 import { jsonResult, readStringParam } from "./common.js";
 import { createAgentToAgentPolicy, resolveSessionReference, resolveMainSessionAlias, resolveInternalSessionKey, stripToolMessages, } from "./sessions-helpers.js";
 const SessionsHistoryToolSchema = Type.Object({
@@ -9,6 +11,63 @@ const SessionsHistoryToolSchema = Type.Object({
     limit: Type.Optional(Type.Number({ minimum: 1 })),
     includeTools: Type.Optional(Type.Boolean()),
 });
+/** Hard cap on the serialized JSON size of the returned messages array. */
+const SESSIONS_HISTORY_MAX_BYTES = 512 * 1024;
+/** Per-block text truncation limit (in UTF-16 chars). */
+const SESSIONS_HISTORY_TEXT_MAX_CHARS = 32_000;
+function truncateHistoryText(text, maxChars) {
+    if (text.length <= maxChars)
+        return text;
+    return `${truncateUtf16Safe(text, maxChars)}…(truncated)`;
+}
+function sanitizeHistoryContentBlock(block) {
+    if (!block || typeof block !== "object")
+        return block;
+    const rec = block;
+    if (typeof rec.text === "string") {
+        return { ...rec, text: truncateHistoryText(rec.text, SESSIONS_HISTORY_TEXT_MAX_CHARS) };
+    }
+    return block;
+}
+function sanitizeHistoryMessage(msg) {
+    if (!msg || typeof msg !== "object")
+        return msg;
+    const rec = msg;
+    if (typeof rec.content === "string") {
+        return { ...rec, content: truncateHistoryText(rec.content, SESSIONS_HISTORY_TEXT_MAX_CHARS) };
+    }
+    if (Array.isArray(rec.content)) {
+        return { ...rec, content: rec.content.map(sanitizeHistoryContentBlock) };
+    }
+    return msg;
+}
+function jsonUtf8Bytes(value) {
+    try {
+        return Buffer.byteLength(JSON.stringify(value), "utf8");
+    }
+    catch {
+        return Buffer.byteLength(String(value), "utf8");
+    }
+}
+function enforceSessionsHistoryHardCap(messages) {
+    const sanitized = messages.map(sanitizeHistoryMessage);
+    const { items, bytes } = capArrayByJsonBytes(sanitized, SESSIONS_HISTORY_MAX_BYTES);
+    const droppedMessages = sanitized.length - items.length;
+    // Count how many messages had content truncated by comparing original vs sanitized text.
+    let contentTruncated = 0;
+    for (let i = 0; i < messages.length; i++) {
+        if (jsonUtf8Bytes(messages[i]) !== jsonUtf8Bytes(sanitized[i])) {
+            contentTruncated++;
+        }
+    }
+    return {
+        messages: items,
+        truncated: droppedMessages > 0 || contentTruncated > 0,
+        droppedMessages,
+        contentTruncated,
+        bytes,
+    };
+}
 function resolveSandboxSessionToolsVisibility(cfg) {
     return cfg.agents?.defaults?.sandbox?.sessionToolsVisibility ?? "spawned";
 }
@@ -109,9 +168,18 @@ export function createSessionsHistoryTool(opts) {
             }));
             const rawMessages = Array.isArray(result?.messages) ? result.messages : [];
             const messages = includeTools ? rawMessages : stripToolMessages(rawMessages);
+            const capped = enforceSessionsHistoryHardCap(messages);
             return jsonResult({
                 sessionKey: displayKey,
-                messages,
+                messages: capped.messages,
+                ...(capped.truncated
+                    ? {
+                        truncated: true,
+                        droppedMessages: capped.droppedMessages,
+                        contentTruncated: capped.contentTruncated,
+                        bytes: capped.bytes,
+                    }
+                    : {}),
             });
         },
     };