@poolzin/pool-bot 2026.2.24 → 2026.2.26

package/dist/agents/tool-policy.js

@@ -1,3 +1,15 @@
+// Keep tool-policy browser-safe: do not import tools/common at runtime.
+function wrapOwnerOnlyToolExecution(tool, senderIsOwner) {
+    if (tool.ownerOnly !== true || senderIsOwner || !tool.execute) {
+        return tool;
+    }
+    return {
+        ...tool,
+        execute: async () => {
+            throw new Error("Tool restricted to owner senders.");
+        },
+    };
+}
 const TOOL_NAME_ALIASES = {
     bash: "exec",
     "apply-patch": "apply_patch",
@@ -16,6 +28,7 @@ export const TOOL_GROUPS = {
         "sessions_history",
         "sessions_send",
         "sessions_spawn",
+        "subagents",
         "session_status",
     ],
     // UI helpers
@@ -26,7 +39,7 @@ export const TOOL_GROUPS = {
     "group:messaging": ["message"],
     // Nodes + device tools
     "group:nodes": ["nodes"],
-    // All Poolbot native tools (excludes provider plugins).
+    // All Pool Bot native tools (excludes provider plugins).
     "group:poolbot": [
         "browser",
         "canvas",
@@ -39,6 +52,7 @@ export const TOOL_GROUPS = {
         "sessions_history",
         "sessions_send",
         "sessions_spawn",
+        "subagents",
         "session_status",
         "memory_search",
         "memory_get",
@@ -47,7 +61,7 @@ export const TOOL_GROUPS = {
         "image",
     ],
 };
-const OWNER_ONLY_TOOL_NAMES = new Set(["whatsapp_login"]);
+const OWNER_ONLY_TOOL_NAME_FALLBACKS = new Set(["whatsapp_login", "cron", "gateway"]);
 const TOOL_PROFILES = {
     minimal: {
         allow: ["session_status"],
@@ -71,31 +85,27 @@ export function normalizeToolName(name) {
     return TOOL_NAME_ALIASES[normalized] ?? normalized;
 }
 export function isOwnerOnlyToolName(name) {
-    return OWNER_ONLY_TOOL_NAMES.has(normalizeToolName(name));
+    return OWNER_ONLY_TOOL_NAME_FALLBACKS.has(normalizeToolName(name));
+}
+function isOwnerOnlyTool(tool) {
+    return tool.ownerOnly === true || isOwnerOnlyToolName(tool.name);
 }
 export function applyOwnerOnlyToolPolicy(tools, senderIsOwner) {
     const withGuard = tools.map((tool) => {
-        if (!isOwnerOnlyToolName(tool.name)) {
+        if (!isOwnerOnlyTool(tool)) {
             return tool;
         }
-        if (senderIsOwner || !tool.execute) {
-            return tool;
-        }
-        return {
-            ...tool,
-            execute: async () => {
-                throw new Error("Tool restricted to owner senders.");
-            },
-        };
+        return wrapOwnerOnlyToolExecution(tool, senderIsOwner);
     });
     if (senderIsOwner) {
         return withGuard;
     }
-    return withGuard.filter((tool) => !isOwnerOnlyToolName(tool.name));
+    return withGuard.filter((tool) => !isOwnerOnlyTool(tool));
 }
 export function normalizeToolList(list) {
-    if (!list)
+    if (!list) {
         return [];
+    }
     return list.map(normalizeToolName).filter(Boolean);
 }
 export function expandToolGroups(list) {
@@ -114,14 +124,17 @@ export function expandToolGroups(list) {
 export function collectExplicitAllowlist(policies) {
     const entries = [];
     for (const policy of policies) {
-        if (!policy?.allow)
+        if (!policy?.allow) {
             continue;
+        }
         for (const value of policy.allow) {
-            if (typeof value !== "string")
+            if (typeof value !== "string") {
                 continue;
+            }
             const trimmed = value.trim();
-            if (trimmed)
+            if (trimmed) {
                 entries.push(trimmed);
+            }
         }
     }
     return entries;
@@ -131,8 +144,9 @@ export function buildPluginToolGroups(params) {
     const byPlugin = new Map();
     for (const tool of params.tools) {
         const meta = params.toolMeta(tool);
-        if (!meta)
+        if (!meta) {
             continue;
+        }
         const name = normalizeToolName(tool.name);
         all.push(name);
         const pluginId = meta.pluginId.toLowerCase();
@@ -143,8 +157,9 @@ export function buildPluginToolGroups(params) {
     return { all, byPlugin };
 }
 export function expandPluginGroups(list, groups) {
-    if (!list || list.length === 0)
+    if (!list || list.length === 0) {
         return list;
+    }
     const expanded = [];
     for (const entry of list) {
         const normalized = normalizeToolName(entry);
@@ -167,8 +182,9 @@ export function expandPluginGroups(list, groups) {
     return Array.from(new Set(expanded));
 }
 export function expandPolicyWithPluginGroups(policy, groups) {
-    if (!policy)
+    if (!policy) {
         return undefined;
+    }
     return {
         allow: expandPluginGroups(policy.allow, groups),
         deny: expandPluginGroups(policy.deny, groups),
@@ -187,13 +203,19 @@ export function stripPluginOnlyAllowlist(policy, groups, coreTools) {
     const unknownAllowlist = [];
     let hasCoreEntry = false;
     for (const entry of normalized) {
+        if (entry === "*") {
+            hasCoreEntry = true;
+            continue;
+        }
         const isPluginEntry = entry === "group:plugins" || pluginIds.has(entry) || pluginTools.has(entry);
         const expanded = expandToolGroups([entry]);
         const isCoreEntry = expanded.some((tool) => coreTools.has(tool));
-        if (isCoreEntry)
+        if (isCoreEntry) {
             hasCoreEntry = true;
-        if (!isCoreEntry && !isPluginEntry)
+        }
+        if (!isCoreEntry && !isPluginEntry) {
             unknownAllowlist.push(entry);
+        }
     }
     const strippedAllowlist = !hasCoreEntry;
     // When an allowlist contains only plugin tools, we strip it to avoid accidentally
@@ -209,13 +231,16 @@ export function stripPluginOnlyAllowlist(policy, groups, coreTools) {
     };
 }
 export function resolveToolProfilePolicy(profile) {
-    if (!profile)
+    if (!profile) {
         return undefined;
+    }
     const resolved = TOOL_PROFILES[profile];
-    if (!resolved)
+    if (!resolved) {
         return undefined;
-    if (!resolved.allow && !resolved.deny)
+    }
+    if (!resolved.allow && !resolved.deny) {
         return undefined;
+    }
     return {
         allow: resolved.allow ? [...resolved.allow] : undefined,
         deny: resolved.deny ? [...resolved.deny] : undefined,

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

@@ -1,14 +1,35 @@
-import { browserCloseTab, browserFocusTab, browserOpenTab, browserProfiles, browserSnapshot, browserStart, browserStatus, browserStop, browserTabs, } from "../../browser/client.js";
-import { browserAct, browserArmDialog, browserArmFileChooser, browserConsoleMessages, browserNavigate, browserPdfSave, browserScreenshotAction, } from "../../browser/client-actions.js";
 import crypto from "node:crypto";
+import { browserAct, browserArmDialog, browserArmFileChooser, browserConsoleMessages, browserNavigate, browserPdfSave, browserScreenshotAction, } from "../../browser/client-actions.js";
+import { browserCloseTab, browserFocusTab, browserOpenTab, browserProfiles, browserSnapshot, browserStart, browserStatus, browserStop, browserTabs, } from "../../browser/client.js";
 import { resolveBrowserConfig } from "../../browser/config.js";
 import { DEFAULT_AI_SNAPSHOT_MAX_CHARS } from "../../browser/constants.js";
+import { DEFAULT_UPLOAD_DIR, resolveExistingPathsWithinRoot } from "../../browser/paths.js";
+import { applyBrowserProxyPaths, persistBrowserProxyFiles } from "../../browser/proxy-files.js";
 import { loadConfig } from "../../config/config.js";
-import { saveMediaBuffer } from "../../media/store.js";
-import { listNodes, resolveNodeIdFromList } from "./nodes-utils.js";
+import { wrapExternalContent } from "../../security/external-content.js";
 import { BrowserToolSchema } from "./browser-tool.schema.js";
 import { imageResultFromFile, jsonResult, readStringParam } from "./common.js";
 import { callGatewayTool } from "./gateway.js";
+import { listNodes, resolveNodeIdFromList } from "./nodes-utils.js";
+function wrapBrowserExternalJson(params) {
+    const extractedText = JSON.stringify(params.payload, null, 2);
+    const wrappedText = wrapExternalContent(extractedText, {
+        source: "browser",
+        includeWarning: params.includeWarning ?? true,
+    });
+    return {
+        wrappedText,
+        safeDetails: {
+            ok: true,
+            externalContent: {
+                untrusted: true,
+                source: "browser",
+                kind: params.kind,
+                wrapped: true,
+            },
+        },
+    };
+}
 const DEFAULT_BROWSER_PROXY_TIMEOUT_MS = 20_000;
 function isBrowserNode(node) {
     const caps = Array.isArray(node.caps) ? node.caps : [];
@@ -28,8 +49,9 @@ async function resolveBrowserNodeTarget(params) {
     if (params.sandboxBridgeUrl?.trim() && params.target !== "node" && !params.requestedNode) {
         return null;
     }
-    if (params.target && params.target !== "node")
+    if (params.target && params.target !== "node") {
         return null;
+    }
     if (mode === "manual" && params.target !== "node" && !params.requestedNode) {
         return null;
     }
@@ -54,8 +76,9 @@ async function resolveBrowserNodeTarget(params) {
         }
         throw new Error(`Multiple browser-capable nodes connected (${browserNodes.length}). Set gateway.nodes.browser.node or pass node=<id>.`);
     }
-    if (mode === "manual")
+    if (mode === "manual") {
         return null;
+    }
     if (browserNodes.length === 1) {
         const node = browserNodes[0];
         return { nodeId: node.nodeId, label: node.displayName ?? node.remoteIp ?? node.nodeId };
@@ -66,7 +89,7 @@ async function callBrowserProxy(params) {
     const gatewayTimeoutMs = typeof params.timeoutMs === "number" && Number.isFinite(params.timeoutMs)
         ? Math.max(1, Math.floor(params.timeoutMs))
         : DEFAULT_BROWSER_PROXY_TIMEOUT_MS;
-    const payload = (await callGatewayTool("node.invoke", { timeoutMs: gatewayTimeoutMs }, {
+    const payload = await callGatewayTool("node.invoke", { timeoutMs: gatewayTimeoutMs }, {
         nodeId: params.nodeId,
         command: "browser.proxy",
         params: {
@@ -78,44 +101,21 @@ async function callBrowserProxy(params) {
             profile: params.profile,
         },
         idempotencyKey: crypto.randomUUID(),
-    }));
+    });
     const parsed = payload?.payload ??
         (typeof payload?.payloadJSON === "string" && payload.payloadJSON
             ? JSON.parse(payload.payloadJSON)
             : null);
-    if (!parsed || typeof parsed !== "object") {
+    if (!parsed || typeof parsed !== "object" || !("result" in parsed)) {
         throw new Error("browser proxy failed");
     }
     return parsed;
 }
 async function persistProxyFiles(files) {
-    if (!files || files.length === 0)
-        return new Map();
-    const mapping = new Map();
-    for (const file of files) {
-        const buffer = Buffer.from(file.base64, "base64");
-        const saved = await saveMediaBuffer(buffer, file.mimeType, "browser", buffer.byteLength);
-        mapping.set(file.path, saved.path);
-    }
-    return mapping;
+    return await persistBrowserProxyFiles(files);
 }
 function applyProxyPaths(result, mapping) {
-    if (!result || typeof result !== "object")
-        return;
-    const obj = result;
-    if (typeof obj.path === "string" && mapping.has(obj.path)) {
-        obj.path = mapping.get(obj.path);
-    }
-    if (typeof obj.imagePath === "string" && mapping.has(obj.imagePath)) {
-        obj.imagePath = mapping.get(obj.imagePath);
-    }
-    const download = obj.download;
-    if (download && typeof download === "object") {
-        const d = download;
-        if (typeof d.path === "string" && mapping.has(d.path)) {
-            d.path = mapping.get(d.path);
-        }
-    }
+    applyBrowserProxyPaths(result, mapping);
 }
 function resolveBrowserBaseUrl(params) {
     const cfg = loadConfig();
@@ -143,11 +143,11 @@ export function createBrowserTool(opts) {
         label: "Browser",
         name: "browser",
         description: [
-            "Control the browser via Poolbot's browser control server (status/start/stop/profiles/tabs/open/snapshot/screenshot/actions).",
+            "Control the browser via Pool Bot's browser control server (status/start/stop/profiles/tabs/open/snapshot/screenshot/actions).",
             'Profiles: use profile="chrome" for Chrome extension relay takeover (your existing Chrome tabs). Use profile="clawd" for the isolated clawd-managed browser.',
-            'If the user mentions the Chrome extension / Browser Relay / toolbar button / “attach tab”, ALWAYS use profile="chrome" (do not ask which profile).',
+            'If the user mentions the Chrome extension / Browser Relay / toolbar button / "attach tab", ALWAYS use profile="chrome" (do not ask which profile).',
             'When a node-hosted browser proxy is available, the tool may auto-route to it. Pin a node with node=<id|name> or target="node".',
-            "Chrome extension relay needs an attached tab: user must click the Poolbot Browser Relay toolbar icon on the tab (badge ON). If no tab is connected, ask them to attach it.",
+            "Chrome extension relay needs an attached tab: user must click the Pool Bot Browser Relay toolbar icon on the tab (badge ON). If no tab is connected, ask them to attach it.",
             "When using refs from snapshot (e.g. e12), keep the same tab: prefer passing targetId from the snapshot response into subsequent actions (act/click/type/etc).",
             'For stable, self-resolving refs across calls, use snapshot with refs="aria" (Playwright aria-ref ids). Default refs="role" are role+name-based.',
             "Use snapshot+act for UI automation. Avoid act:wait by default; use only in exceptional cases when no reliable UI state exists.",
@@ -254,9 +254,28 @@ export function createBrowserTool(opts) {
                             profile,
                         });
                         const tabs = result.tabs ?? [];
-                        return jsonResult({ tabs });
+                        const wrapped = wrapBrowserExternalJson({
+                            kind: "tabs",
+                            payload: { tabs },
+                            includeWarning: false,
+                        });
+                        return {
+                            content: [{ type: "text", text: wrapped.wrappedText }],
+                            details: { ...wrapped.safeDetails, tabCount: tabs.length },
+                        };
+                    }
+                    {
+                        const tabs = await browserTabs(baseUrl, { profile });
+                        const wrapped = wrapBrowserExternalJson({
+                            kind: "tabs",
+                            payload: { tabs },
+                            includeWarning: false,
+                        });
+                        return {
+                            content: [{ type: "text", text: wrapped.wrappedText }],
+                            details: { ...wrapped.safeDetails, tabCount: tabs.length },
+                        };
                     }
-                    return jsonResult({ tabs: await browserTabs(baseUrl, { profile }) });
                 case "open": {
                     const targetUrl = readStringParam(params, "targetUrl", {
                         required: true,
@@ -305,10 +324,12 @@ export function createBrowserTool(opts) {
                             });
                         return jsonResult(result);
                     }
-                    if (targetId)
+                    if (targetId) {
                         await browserCloseTab(baseUrl, targetId, { profile });
-                    else
+                    }
+                    else {
                         await browserAct(baseUrl, { kind: "close" }, { profile });
+                    }
                     return jsonResult({ ok: true });
                 }
                 case "snapshot": {
@@ -383,20 +404,68 @@ export function createBrowserTool(opts) {
                             profile,
                         });
                     if (snapshot.format === "ai") {
+                        const extractedText = snapshot.snapshot ?? "";
+                        const wrappedSnapshot = wrapExternalContent(extractedText, {
+                            source: "browser",
+                            includeWarning: true,
+                        });
+                        const safeDetails = {
+                            ok: true,
+                            format: snapshot.format,
+                            targetId: snapshot.targetId,
+                            url: snapshot.url,
+                            truncated: snapshot.truncated,
+                            stats: snapshot.stats,
+                            refs: snapshot.refs ? Object.keys(snapshot.refs).length : undefined,
+                            labels: snapshot.labels,
+                            labelsCount: snapshot.labelsCount,
+                            labelsSkipped: snapshot.labelsSkipped,
+                            imagePath: snapshot.imagePath,
+                            imageType: snapshot.imageType,
+                            externalContent: {
+                                untrusted: true,
+                                source: "browser",
+                                kind: "snapshot",
+                                format: "ai",
+                                wrapped: true,
+                            },
+                        };
                         if (labels && snapshot.imagePath) {
                             return await imageResultFromFile({
                                 label: "browser:snapshot",
                                 path: snapshot.imagePath,
-                                extraText: snapshot.snapshot,
-                                details: snapshot,
+                                extraText: wrappedSnapshot,
+                                details: safeDetails,
                             });
                         }
                         return {
-                            content: [{ type: "text", text: snapshot.snapshot }],
-                            details: snapshot,
+                            content: [{ type: "text", text: wrappedSnapshot }],
+                            details: safeDetails,
+                        };
+                    }
+                    {
+                        const wrapped = wrapBrowserExternalJson({
+                            kind: "snapshot",
+                            payload: snapshot,
+                        });
+                        return {
+                            content: [{ type: "text", text: wrapped.wrappedText }],
+                            details: {
+                                ...wrapped.safeDetails,
+                                format: "aria",
+                                targetId: snapshot.targetId,
+                                url: snapshot.url,
+                                nodeCount: snapshot.nodes.length,
+                                externalContent: {
+                                    untrusted: true,
+                                    source: "browser",
+                                    kind: "snapshot",
+                                    format: "aria",
+                                    wrapped: true,
+                                },
+                            },
                         };
                     }
-                    return jsonResult(snapshot);
                 }
                 case "screenshot": {
                     const targetId = readStringParam(params, "targetId");
@@ -458,7 +527,7 @@ export function createBrowserTool(opts) {
                     const level = typeof params.level === "string" ? params.level.trim() : undefined;
                     const targetId = typeof params.targetId === "string" ? params.targetId.trim() : undefined;
                     if (proxyRequest) {
-                        const result = await proxyRequest({
+                        const result = (await proxyRequest({
                             method: "GET",
                             path: "/console",
                             profile,
@@ -466,10 +535,37 @@ export function createBrowserTool(opts) {
                                 level,
                                 targetId,
                             },
+                        }));
+                        const wrapped = wrapBrowserExternalJson({
+                            kind: "console",
+                            payload: result,
+                            includeWarning: false,
+                        });
+                        return {
+                            content: [{ type: "text", text: wrapped.wrappedText }],
+                            details: {
+                                ...wrapped.safeDetails,
+                                targetId: typeof result.targetId === "string" ? result.targetId : undefined,
+                                messageCount: Array.isArray(result.messages) ? result.messages.length : undefined,
+                            },
+                        };
+                    }
+                    {
+                        const result = await browserConsoleMessages(baseUrl, { level, targetId, profile });
+                        const wrapped = wrapBrowserExternalJson({
+                            kind: "console",
+                            payload: result,
+                            includeWarning: false,
                         });
-                        return jsonResult(result);
+                        return {
+                            content: [{ type: "text", text: wrapped.wrappedText }],
+                            details: {
+                                ...wrapped.safeDetails,
+                                targetId: result.targetId,
+                                messageCount: result.messages.length,
+                            },
+                        };
                     }
-                    return jsonResult(await browserConsoleMessages(baseUrl, { level, targetId, profile }));
                 }
                 case "pdf": {
                     const targetId = typeof params.targetId === "string" ? params.targetId.trim() : undefined;
@@ -488,8 +584,18 @@ export function createBrowserTool(opts) {
                 }
                 case "upload": {
                     const paths = Array.isArray(params.paths) ? params.paths.map((p) => String(p)) : [];
-                    if (paths.length === 0)
+                    if (paths.length === 0) {
                         throw new Error("paths required");
+                    }
+                    const uploadPathsResult = await resolveExistingPathsWithinRoot({
+                        rootDir: DEFAULT_UPLOAD_DIR,
+                        requestedPaths: paths,
+                        scopeLabel: `uploads directory (${DEFAULT_UPLOAD_DIR})`,
+                    });
+                    if (!uploadPathsResult.ok) {
+                        throw new Error(uploadPathsResult.error);
+                    }
+                    const normalizedPaths = uploadPathsResult.paths;
                     const ref = readStringParam(params, "ref");
                     const inputRef = readStringParam(params, "inputRef");
                     const element = readStringParam(params, "element");
@@ -503,7 +609,7 @@ export function createBrowserTool(opts) {
                             path: "/hooks/file-chooser",
                             profile,
                             body: {
-                                paths,
+                                paths: normalizedPaths,
                                 ref,
                                 inputRef,
                                 element,
@@ -514,7 +620,7 @@ export function createBrowserTool(opts) {
                         return jsonResult(result);
                     }
                     return jsonResult(await browserArmFileChooser(baseUrl, {
-                        paths,
+                        paths: normalizedPaths,
                         ref,
                         inputRef,
                         element,
@@ -581,9 +687,9 @@ export function createBrowserTool(opts) {
                                 })).tabs ?? [])
                                 : await browserTabs(baseUrl, { profile }).catch(() => []);
                             if (!tabs.length) {
-                                throw new Error("No Chrome tabs are attached via the Poolbot Browser Relay extension. Click the toolbar icon on the tab you want to control (badge ON), then retry.");
+                                throw new Error("No Chrome tabs are attached via the Pool Bot Browser Relay extension. Click the toolbar icon on the tab you want to control (badge ON), then retry.", { cause: err });
                             }
-                            throw new Error(`Chrome tab not found (stale targetId?). Run action=tabs profile="chrome" and use one of the returned targetIds.`);
+                            throw new Error(`Chrome tab not found (stale targetId?). Run action=tabs profile="chrome" and use one of the returned targetIds.`, { cause: err });
                         }
                         throw err;
                     }

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

@@ -1,8 +1,12 @@
 import crypto from "node:crypto";
 import fs from "node:fs/promises";
+import path from "node:path";
 import { Type } from "@sinclair/typebox";
 import { writeBase64ToFile } from "../../cli/nodes-camera.js";
 import { canvasSnapshotTempPath, parseCanvasSnapshotPayload } from "../../cli/nodes-canvas.js";
+import { logVerbose, shouldLogVerbose } from "../../globals.js";
+import { isInboundPathAllowed } from "../../media/inbound-path-policy.js";
+import { getDefaultMediaLocalRoots } from "../../media/local-roots.js";
 import { imageMimeFromFormat } from "../../media/mime.js";
 import { resolveImageSanitizationLimits } from "../image-sanitization.js";
 import { optionalStringEnum, stringEnum } from "../schema/typebox.js";
@@ -19,6 +23,28 @@ const CANVAS_ACTIONS = [
     "a2ui_reset",
 ];
 const CANVAS_SNAPSHOT_FORMATS = ["png", "jpg", "jpeg"];
+async function readJsonlFromPath(jsonlPath) {
+    const trimmed = jsonlPath.trim();
+    if (!trimmed) {
+        return "";
+    }
+    const resolved = path.resolve(trimmed);
+    const roots = getDefaultMediaLocalRoots();
+    if (!isInboundPathAllowed({ filePath: resolved, roots })) {
+        if (shouldLogVerbose()) {
+            logVerbose(`Blocked canvas jsonlPath outside allowed roots: ${resolved}`);
+        }
+        throw new Error("jsonlPath outside allowed roots");
+    }
+    const canonical = await fs.realpath(resolved).catch(() => resolved);
+    if (!isInboundPathAllowed({ filePath: canonical, roots })) {
+        if (shouldLogVerbose()) {
+            logVerbose(`Blocked canvas jsonlPath outside allowed roots: ${canonical}`);
+        }
+        throw new Error("jsonlPath outside allowed roots");
+    }
+    return await fs.readFile(canonical, "utf8");
+}
 // Flattened schema: runtime validates per-action requirements.
 const CanvasToolSchema = Type.Object({
     action: stringEnum(CANVAS_ACTIONS),
@@ -145,7 +171,7 @@ export function createCanvasTool(options) {
                     const jsonl = typeof params.jsonl === "string" && params.jsonl.trim()
                         ? params.jsonl
                         : typeof params.jsonlPath === "string" && params.jsonlPath.trim()
-                            ? await fs.readFile(params.jsonlPath.trim(), "utf8")
+                            ? await readJsonlFromPath(params.jsonlPath)
                             : "";
                     if (!jsonl.trim()) {
                         throw new Error("jsonl or jsonlPath required");

package/dist/agents/tools/common.js

@@ -1,6 +1,7 @@
 import fs from "node:fs/promises";
 import { detectMime } from "../../media/mime.js";
 import { sanitizeToolResultImages } from "../tool-images.js";
+export const OWNER_ONLY_TOOL_ERROR = "Tool restricted to owner senders.";
 export class ToolInputError extends Error {
     status = 400;
     constructor(message) {
@@ -8,6 +9,13 @@ export class ToolInputError extends Error {
         this.name = "ToolInputError";
     }
 }
+export class ToolAuthorizationError extends ToolInputError {
+    status = 403;
+    constructor(message) {
+        super(message);
+        this.name = "ToolAuthorizationError";
+    }
+}
 export function createActionGate(actions) {
     return (key, defaultValue = true) => {
         const value = actions?.[key];
@@ -131,6 +139,17 @@ export function jsonResult(payload) {
         details: payload,
     };
 }
+export function wrapOwnerOnlyToolExecution(tool, senderIsOwner) {
+    if (tool.ownerOnly !== true || senderIsOwner || !tool.execute) {
+        return tool;
+    }
+    return {
+        ...tool,
+        execute: async () => {
+            throw new Error(OWNER_ONLY_TOOL_ERROR);
+        },
+    };
+}
 export async function imageResult(params) {
     const content = [
         {
@@ -162,3 +181,29 @@ export async function imageResultFromFile(params) {
         imageSanitization: params.imageSanitization,
     });
 }
+/**
+ * Validate and parse an `availableTags` parameter from untrusted input.
+ * Returns `undefined` when the value is missing or not an array.
+ * Entries that lack a string `name` are silently dropped.
+ */
+export function parseAvailableTags(raw) {
+    if (raw === undefined || raw === null) {
+        return undefined;
+    }
+    if (!Array.isArray(raw)) {
+        return undefined;
+    }
+    const result = raw
+        .filter((t) => typeof t === "object" && t !== null && typeof t.name === "string")
+        .map((t) => ({
+        ...(t.id !== undefined && typeof t.id === "string" ? { id: t.id } : {}),
+        name: t.name,
+        ...(typeof t.moderated === "boolean" ? { moderated: t.moderated } : {}),
+        ...(t.emoji_id === null || typeof t.emoji_id === "string" ? { emoji_id: t.emoji_id } : {}),
+        ...(t.emoji_name === null || typeof t.emoji_name === "string"
+            ? { emoji_name: t.emoji_name }
+            : {}),
+    }));
+    // Return undefined instead of empty array to avoid accidentally clearing all tags
+    return result.length ? result : undefined;
+}

package/dist/agents/tools/cron-tool.test-helpers.js

@@ -0,0 +1,12 @@
+import { vi } from "vitest";
+export const callGatewayMock = vi.fn();
+vi.mock("../../gateway/call.js", () => ({
+    callGateway: (opts) => callGatewayMock(opts),
+}));
+vi.mock("../agent-scope.js", () => ({
+    resolveSessionAgentId: () => "agent-123",
+}));
+export function resetCronToolGatewayMock() {
+    callGatewayMock.mockReset();
+    callGatewayMock.mockResolvedValue({ ok: true });
+}