@poolzin/pool-bot 2026.2.23 → 2026.2.25

package/dist/agents/pi-embedded-payloads.js

@@ -0,0 +1 @@
+export {};

package/dist/agents/pi-embedded-runner/run.overflow-compaction.fixture.js

@@ -0,0 +1,34 @@
+export function makeAttemptResult(overrides = {}) {
+    return {
+        aborted: false,
+        timedOut: false,
+        timedOutDuringCompaction: false,
+        promptError: null,
+        sessionIdUsed: "test-session",
+        assistantTexts: ["Hello!"],
+        toolMetas: [],
+        lastAssistant: undefined,
+        messagesSnapshot: [],
+        didSendViaMessagingTool: false,
+        messagingToolSentTexts: [],
+        messagingToolSentMediaUrls: [],
+        messagingToolSentTargets: [],
+        cloudCodeAssistFormatError: false,
+        ...overrides,
+    };
+}
+export function mockOverflowRetrySuccess(params) {
+    const overflowError = new Error(params.overflowMessage ?? "request_too_large: Request size exceeds model context window");
+    params.runEmbeddedAttempt.mockResolvedValueOnce(makeAttemptResult({ promptError: overflowError }));
+    params.runEmbeddedAttempt.mockResolvedValueOnce(makeAttemptResult({ promptError: null }));
+    params.compactDirect.mockResolvedValueOnce({
+        ok: true,
+        compacted: true,
+        result: {
+            summary: "Compacted session",
+            firstKeptEntryId: "entry-5",
+            tokensBefore: 150000,
+        },
+    });
+    return overflowError;
+}

package/dist/agents/skills.test-helpers.js

@@ -0,0 +1,13 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+export async function writeSkill(params) {
+    const { dir, name, description, body } = params;
+    await fs.mkdir(dir, { recursive: true });
+    await fs.writeFile(path.join(dir, "SKILL.md"), `---
+name: ${name}
+description: ${description}
+---
+
+${body ?? `# ${name}\n`}
+`, "utf-8");
+}

package/dist/agents/stable-stringify.js

@@ -0,0 +1,12 @@
+export function stableStringify(value) {
+    if (value === null || typeof value !== "object") {
+        return JSON.stringify(value) ?? "null";
+    }
+    if (Array.isArray(value)) {
+        return `[${value.map((entry) => stableStringify(entry)).join(",")}]`;
+    }
+    const record = value;
+    const keys = Object.keys(record).toSorted();
+    const entries = keys.map((key) => `${JSON.stringify(key)}:${stableStringify(record[key])}`);
+    return `{${entries.join(",")}}`;
+}

package/dist/agents/subagent-registry.mocks.shared.js

@@ -0,0 +1,12 @@
+import { vi } from "vitest";
+const noop = () => { };
+vi.mock("../gateway/call.js", () => ({
+    callGateway: vi.fn(async () => ({
+        status: "ok",
+        startedAt: 111,
+        endedAt: 222,
+    })),
+}));
+vi.mock("../infra/agent-events.js", () => ({
+    onAgentEvent: vi.fn(() => noop),
+}));

package/dist/agents/test-helpers/assistant-message-fixtures.js

@@ -0,0 +1,29 @@
+const ZERO_USAGE = {
+    input: 0,
+    output: 0,
+    cacheRead: 0,
+    cacheWrite: 0,
+    totalTokens: 0,
+    cost: {
+        input: 0,
+        output: 0,
+        cacheRead: 0,
+        cacheWrite: 0,
+        total: 0,
+    },
+};
+export function makeAssistantMessageFixture(overrides = {}) {
+    const errorText = typeof overrides.errorMessage === "string" ? overrides.errorMessage : "error";
+    return {
+        role: "assistant",
+        api: "openai-responses",
+        provider: "openai",
+        model: "test-model",
+        usage: ZERO_USAGE,
+        timestamp: 0,
+        stopReason: "error",
+        errorMessage: errorText,
+        content: [{ type: "text", text: errorText }],
+        ...overrides,
+    };
+}

package/dist/agents/test-helpers/pi-tools-sandbox-context.js

@@ -0,0 +1,27 @@
+export function createPiToolsSandboxContext(params) {
+    const workspaceDir = params.workspaceDir;
+    return {
+        enabled: true,
+        sessionKey: params.sessionKey ?? "sandbox:test",
+        workspaceDir,
+        agentWorkspaceDir: params.agentWorkspaceDir ?? workspaceDir,
+        workspaceAccess: params.workspaceAccess ?? "rw",
+        containerName: params.containerName ?? "poolbot-sbx-test",
+        containerWorkdir: params.containerWorkdir ?? "/workspace",
+        fsBridge: params.fsBridge,
+        docker: {
+            image: "poolbot-sandbox:bookworm-slim",
+            containerPrefix: "poolbot-sbx-",
+            workdir: "/workspace",
+            readOnlyRoot: true,
+            tmpfs: [],
+            network: "none",
+            user: "1000:1000",
+            capDrop: ["ALL"],
+            env: { LANG: "C.UTF-8" },
+            ...params.dockerOverrides,
+        },
+        tools: params.tools ?? { allow: [], deny: [] },
+        browserAllowHostControl: params.browserAllowHostControl ?? false,
+    };
+}

package/dist/agents/tool-policy-shared.js

@@ -0,0 +1,108 @@
+const TOOL_NAME_ALIASES = {
+    bash: "exec",
+    "apply-patch": "apply_patch",
+};
+export const TOOL_GROUPS = {
+    // NOTE: Keep canonical (lowercase) tool names here.
+    "group:memory": ["memory_search", "memory_get"],
+    "group:web": ["web_search", "web_fetch"],
+    // Basic workspace/file tools
+    "group:fs": ["read", "write", "edit", "apply_patch"],
+    // Host/runtime execution tools
+    "group:runtime": ["exec", "process"],
+    // Session management tools
+    "group:sessions": [
+        "sessions_list",
+        "sessions_history",
+        "sessions_send",
+        "sessions_spawn",
+        "subagents",
+        "session_status",
+    ],
+    // UI helpers
+    "group:ui": ["browser", "canvas"],
+    // Automation + infra
+    "group:automation": ["cron", "gateway"],
+    // Messaging surface
+    "group:messaging": ["message"],
+    // Nodes + device tools
+    "group:nodes": ["nodes"],
+    // All Pool Bot native tools (excludes provider plugins).
+    "group:poolbot": [
+        "browser",
+        "canvas",
+        "nodes",
+        "cron",
+        "message",
+        "gateway",
+        "agents_list",
+        "sessions_list",
+        "sessions_history",
+        "sessions_send",
+        "sessions_spawn",
+        "subagents",
+        "session_status",
+        "memory_search",
+        "memory_get",
+        "web_search",
+        "web_fetch",
+        "image",
+    ],
+};
+const TOOL_PROFILES = {
+    minimal: {
+        allow: ["session_status"],
+    },
+    coding: {
+        allow: ["group:fs", "group:runtime", "group:sessions", "group:memory", "image"],
+    },
+    messaging: {
+        allow: [
+            "group:messaging",
+            "sessions_list",
+            "sessions_history",
+            "sessions_send",
+            "session_status",
+        ],
+    },
+    full: {},
+};
+export function normalizeToolName(name) {
+    const normalized = name.trim().toLowerCase();
+    return TOOL_NAME_ALIASES[normalized] ?? normalized;
+}
+export function normalizeToolList(list) {
+    if (!list) {
+        return [];
+    }
+    return list.map(normalizeToolName).filter(Boolean);
+}
+export function expandToolGroups(list) {
+    const normalized = normalizeToolList(list);
+    const expanded = [];
+    for (const value of normalized) {
+        const group = TOOL_GROUPS[value];
+        if (group) {
+            expanded.push(...group);
+            continue;
+        }
+        expanded.push(value);
+    }
+    return Array.from(new Set(expanded));
+}
+export function resolveToolProfilePolicy(profile) {
+    if (!profile) {
+        return undefined;
+    }
+    const resolved = TOOL_PROFILES[profile];
+    if (!resolved) {
+        return undefined;
+    }
+    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, resolvePathsWithinRoot } 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 = resolvePathsWithinRoot({
+                        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/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 });
+}

package/dist/agents/tools/discord-actions-moderation-shared.js

@@ -0,0 +1,27 @@
+import { PermissionFlagsBits } from "discord-api-types/v10";
+import { readNumberParam, readStringParam } from "./common.js";
+const moderationPermissions = {
+    timeout: PermissionFlagsBits.ModerateMembers,
+    kick: PermissionFlagsBits.KickMembers,
+    ban: PermissionFlagsBits.BanMembers,
+};
+export function isDiscordModerationAction(action) {
+    return action === "timeout" || action === "kick" || action === "ban";
+}
+export function requiredGuildPermissionForModerationAction(action) {
+    return moderationPermissions[action];
+}
+export function readDiscordModerationCommand(action, params) {
+    if (!isDiscordModerationAction(action)) {
+        throw new Error(`Unsupported Discord moderation action: ${action}`);
+    }
+    return {
+        action,
+        guildId: readStringParam(params, "guildId", { required: true }),
+        userId: readStringParam(params, "userId", { required: true }),
+        durationMinutes: readNumberParam(params, "durationMinutes", { integer: true }),
+        until: readStringParam(params, "until"),
+        reason: readStringParam(params, "reason"),
+        deleteMessageDays: readNumberParam(params, "deleteMessageDays", { integer: true }),
+    };
+}