@spinabot/brigade 1.6.0 → 1.7.0

package/dist/agents/channels/discord/probe.js

@@ -0,0 +1,193 @@
+/**
+ * Discord status / doctor probe — a lightweight `GET /users/@me` reachability
+ * check.
+ *
+ * Discord is token-based and stateless on disk (the Gateway keeps no local creds
+ * the status command can stat), so "is this channel actually working?" can only
+ * be answered by asking Discord. This probe does the cheapest possible call — a
+ * single `GET /users/@me` over plain HTTPS (no `discord.js`, no gateway socket)
+ * with the `Authorization: Bot <token>` header — and reports the bot's identity
+ * so `brigade channels status` and `brigade doctor` can show real Discord health.
+ *
+ * It deliberately does NOT import `discord.js`: a status check must stay fast +
+ * dependency-light, and `/users/@me` is a trivial GET. The bot token is never
+ * logged; it rides in the `Authorization` header which is built locally and
+ * discarded.
+ *
+ * Returns a structured result the caller renders; never throws — a network
+ * failure / invalid token surfaces as `{ ok: false, error }` so the status
+ * command degrades gracefully instead of crashing. Discord mirror of
+ * `slack/probe.ts`.
+ */
+import { stripBotPrefix } from "./account-config.js";
+const DISCORD_ME_URL = "https://discord.com/api/v10/users/@me";
+/** Application-metadata endpoint — carries the `flags` bitfield we decode for the MESSAGE CONTENT intent. */
+const DISCORD_APP_URL = "https://discord.com/api/v10/oauth2/applications/@me";
+const DEFAULT_PROBE_TIMEOUT_MS = 8_000;
+/**
+ * Application-flag bits that indicate the bot HAS the privileged MESSAGE CONTENT
+ * intent. `GATEWAY_MESSAGE_CONTENT` (1 << 18) is set when the intent is enabled;
+ * `GATEWAY_MESSAGE_CONTENT_LIMITED` (1 << 19) when it's available only to a
+ * limited number of servers (still readable). Neither set, with the intent
+ * requested, means it's DISABLED — the bot connects but can't read message text.
+ */
+const FLAG_MESSAGE_CONTENT = 1 << 18;
+const FLAG_MESSAGE_CONTENT_LIMITED = 1 << 19;
+/**
+ * Application-flag bits for the other two privileged intents. GUILD MEMBERS
+ * (`1<<14` full / `1<<15` limited) is needed to receive member-join / role
+ * events + populate the member list; PRESENCE (`1<<12` full / `1<<13` limited)
+ * is needed to read member presence. Neither set means the intent is DISABLED.
+ */
+const FLAG_GUILD_MEMBERS = 1 << 14;
+const FLAG_GUILD_MEMBERS_LIMITED = 1 << 15;
+const FLAG_PRESENCE = 1 << 12;
+const FLAG_PRESENCE_LIMITED = 1 << 13;
+/**
+ * Decode the MESSAGE CONTENT intent state from an application `flags` bitfield.
+ * `enabled` (full), `limited` (limited rollout — still reads content), or
+ * `disabled` (neither bit set). Returns `undefined` when `flags` isn't a number
+ * (the flags fetch was skipped / failed) so callers don't warn on missing data.
+ */
+export function decodeMessageContentIntent(flags) {
+    if (typeof flags !== "number" || !Number.isFinite(flags))
+        return undefined;
+    if ((flags & FLAG_MESSAGE_CONTENT) !== 0)
+        return "enabled";
+    if ((flags & FLAG_MESSAGE_CONTENT_LIMITED) !== 0)
+        return "limited";
+    return "disabled";
+}
+/** Decode one intent's enabled/limited/disabled state from its two flag bits. */
+function decodeIntentState(flags, enabledBit, limitedBit) {
+    if ((flags & enabledBit) !== 0)
+        return "enabled";
+    if ((flags & limitedBit) !== 0)
+        return "limited";
+    return "disabled";
+}
+/**
+ * Decode ALL three privileged gateway intents (message content, guild members,
+ * presence) from an application `flags` bitfield. Returns `undefined` when
+ * `flags` isn't a finite number (the flags fetch was skipped / failed) so
+ * callers don't warn on missing data.
+ */
+export function decodePrivilegedIntents(flags) {
+    if (typeof flags !== "number" || !Number.isFinite(flags))
+        return undefined;
+    return {
+        messageContent: decodeIntentState(flags, FLAG_MESSAGE_CONTENT, FLAG_MESSAGE_CONTENT_LIMITED),
+        guildMembers: decodeIntentState(flags, FLAG_GUILD_MEMBERS, FLAG_GUILD_MEMBERS_LIMITED),
+        presence: decodeIntentState(flags, FLAG_PRESENCE, FLAG_PRESENCE_LIMITED),
+    };
+}
+/** Operator-facing warning surfaced when the MESSAGE CONTENT intent is disabled. */
+export const MESSAGE_CONTENT_DISABLED_WARNING = "Enable the MESSAGE CONTENT intent in the Discord Developer Portal — the bot can't read channel messages without it.";
+/**
+ * Best-effort fetch of the bot's application `flags`, decoded into the MESSAGE
+ * CONTENT intent state. Runs only AFTER `/users/@me` succeeds (the token is
+ * known good). A failed fetch / non-ok / unparseable body returns `undefined` so
+ * the probe NEVER fails on it — the intent state is observability, not health.
+ */
+async function probePrivilegedIntents(doFetch, token, signal) {
+    try {
+        const res = await doFetch(DISCORD_APP_URL, {
+            method: "GET",
+            headers: { Authorization: `Bot ${token}`, "content-type": "application/json" },
+            signal,
+        });
+        if (!res.ok)
+            return undefined;
+        const body = (await res.json());
+        return decodePrivilegedIntents(body?.flags);
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Run a `GET /users/@me` probe. Resolves to a structured result describing
+ * whether the token is valid + Discord is reachable, plus the bot identity. On
+ * success it ALSO best-effort decodes the privileged MESSAGE CONTENT intent
+ * (`/oauth2/applications/@me` → `flags`) and surfaces a warning when it's
+ * disabled — without that intent the bot connects but can't read channel
+ * messages. Never rejects.
+ */
+export async function probeDiscord(args) {
+    const started = Date.now();
+    const token = stripBotPrefix((args.token ?? "").trim());
+    if (!token) {
+        return { ok: false, error: "no Discord bot token configured", elapsedMs: 0 };
+    }
+    const doFetch = args.fetchImpl ?? fetch;
+    const timeoutMs = args.timeoutMs ?? DEFAULT_PROBE_TIMEOUT_MS;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    if (typeof timer.unref === "function")
+        timer.unref();
+    try {
+        const res = await doFetch(DISCORD_ME_URL, {
+            method: "GET",
+            headers: {
+                Authorization: `Bot ${token}`,
+                "content-type": "application/json",
+            },
+            signal: controller.signal,
+        });
+        const elapsedMs = Date.now() - started;
+        let body = null;
+        try {
+            body = (await res.json());
+        }
+        catch {
+            body = null;
+        }
+        if (!res.ok) {
+            // 401 = bad/expired token; otherwise surface the status + any message.
+            return {
+                ok: false,
+                status: res.status,
+                error: res.status === 401
+                    ? "Discord rejected the bot token — reset it in the Developer Portal and paste the fresh token."
+                    : body?.message
+                        ? `Discord /users/@me failed (${body.message}).`
+                        : `Discord /users/@me failed (HTTP ${res.status}).`,
+                elapsedMs,
+            };
+        }
+        // Token is good — best-effort decode ALL privileged intents (never fails the
+        // probe). Reuses the same abort signal/timeout window as the identity call.
+        const privilegedIntents = await probePrivilegedIntents(doFetch, token, controller.signal);
+        const messageContentIntent = privilegedIntents?.messageContent;
+        return {
+            ok: true,
+            status: res.status,
+            elapsedMs,
+            bot: {
+                ...(typeof body?.id === "string" ? { id: body.id } : {}),
+                ...(typeof body?.username === "string" ? { name: body.username } : {}),
+                ...(typeof body?.discriminator === "string" && body.discriminator !== "0" ? { discriminator: body.discriminator } : {}),
+            },
+            ...(privilegedIntents ? { privilegedIntents } : {}),
+            ...(messageContentIntent ? { messageContentIntent } : {}),
+            ...(messageContentIntent === "disabled" ? { messageContentWarning: MESSAGE_CONTENT_DISABLED_WARNING } : {}),
+        };
+    }
+    catch (err) {
+        const elapsedMs = Date.now() - started;
+        const aborted = controller.signal.aborted;
+        return {
+            ok: false,
+            error: aborted
+                ? `Discord /users/@me timed out after ${timeoutMs}ms`
+                : err instanceof Error
+                    ? err.message
+                    : String(err),
+            elapsedMs,
+        };
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+//# sourceMappingURL=probe.js.map

package/dist/agents/channels/discord/probe.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"probe.js","sourceRoot":"","sources":["../../../../src/agents/channels/discord/probe.ts"],"names":[],"mappings":"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"}

package/dist/agents/channels/discord/reasoning-lane.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Discord reasoning-lane split (OPTIONAL, default OFF).
+ *
+ * Brigade strips `<think>…</think>` reasoning from every channel reply via the
+ * shared `sanitizeReplyForChannel` — recipients see only the final answer. For
+ * Discord an operator can OPT IN (config `channels.discord.surfaceReasoning:
+ * true`) to ALSO receive the reasoning trace as a separate, prefixed message.
+ *
+ * This module is the pure splitter: given the raw agent reply, it returns
+ * `{ reasoningText?, answerText }`. When surfacing is OFF the pipeline never
+ * calls this and behavior is byte-identical to today (strip + send answer). When
+ * ON, the pipeline sends `reasoningText` first (a `🧠 Reasoning:` block) then the
+ * normal sanitized answer.
+ *
+ * The answer half is computed with the SAME sanitizer the default path uses, so
+ * enabling reasoning never changes what the answer message contains — it only
+ * ADDS the reasoning message in front.
+ *
+ * Pure / deterministic / dependency-light (re-uses `sanitizeReplyForChannel`).
+ * Discord mirror of `slack/reasoning-lane.ts`.
+ */
+/** Prefix on the reasoning message so the recipient knows it's the trace. */
+export declare const REASONING_PREFIX = "\uD83E\uDDE0 Reasoning:\n";
+export interface DiscordReasoningSplit {
+    /** The extracted reasoning trace (already prefixed), or undefined when none. */
+    reasoningText?: string;
+    /** The user-facing answer (sanitized exactly as the default path produces). */
+    answerText: string;
+}
+/**
+ * Extract the concatenated text INSIDE `<think>…</think>` blocks. Handles
+ * multiple blocks and an unclosed trailing block (model truncated mid-thought).
+ * Returns "" when there's no reasoning content.
+ */
+export declare function extractReasoning(text: string): string;
+/**
+ * Split a raw agent reply into an optional reasoning message + the sanitized
+ * answer. The answer is identical to `sanitizeReplyForChannel(raw)`; the
+ * reasoning is only populated when a `<think>` block carried content.
+ */
+export declare function splitDiscordReasoning(raw: string): DiscordReasoningSplit;
+//# sourceMappingURL=reasoning-lane.d.ts.map

package/dist/agents/channels/discord/reasoning-lane.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reasoning-lane.d.ts","sourceRoot":"","sources":["../../../../src/agents/channels/discord/reasoning-lane.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAIH,6EAA6E;AAC7E,eAAO,MAAM,gBAAgB,8BAAoB,CAAC;AAKlD,MAAM,WAAW,qBAAqB;IACrC,gFAAgF;IAChF,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,+EAA+E;IAC/E,UAAU,EAAE,MAAM,CAAC;CACnB;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAoBrD;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,MAAM,GAAG,qBAAqB,CAKxE"}

package/dist/agents/channels/discord/reasoning-lane.js

@@ -0,0 +1,68 @@
+/**
+ * Discord reasoning-lane split (OPTIONAL, default OFF).
+ *
+ * Brigade strips `<think>…</think>` reasoning from every channel reply via the
+ * shared `sanitizeReplyForChannel` — recipients see only the final answer. For
+ * Discord an operator can OPT IN (config `channels.discord.surfaceReasoning:
+ * true`) to ALSO receive the reasoning trace as a separate, prefixed message.
+ *
+ * This module is the pure splitter: given the raw agent reply, it returns
+ * `{ reasoningText?, answerText }`. When surfacing is OFF the pipeline never
+ * calls this and behavior is byte-identical to today (strip + send answer). When
+ * ON, the pipeline sends `reasoningText` first (a `🧠 Reasoning:` block) then the
+ * normal sanitized answer.
+ *
+ * The answer half is computed with the SAME sanitizer the default path uses, so
+ * enabling reasoning never changes what the answer message contains — it only
+ * ADDS the reasoning message in front.
+ *
+ * Pure / deterministic / dependency-light (re-uses `sanitizeReplyForChannel`).
+ * Discord mirror of `slack/reasoning-lane.ts`.
+ */
+import { sanitizeReplyForChannel } from "../reply-sanitizer.js";
+/** Prefix on the reasoning message so the recipient knows it's the trace. */
+export const REASONING_PREFIX = "🧠 Reasoning:\n";
+/** Matches a `<think>`/`<thinking>`/`<thought>` open/close tag. */
+const THINK_TAG_RE = /<\s*(\/?)\s*(?:think(?:ing)?|thought)\b[^<>]*>/gi;
+/**
+ * Extract the concatenated text INSIDE `<think>…</think>` blocks. Handles
+ * multiple blocks and an unclosed trailing block (model truncated mid-thought).
+ * Returns "" when there's no reasoning content.
+ */
+export function extractReasoning(text) {
+    if (!text)
+        return "";
+    const parts = [];
+    let inThink = false;
+    let lastIndex = 0;
+    THINK_TAG_RE.lastIndex = 0;
+    for (const match of text.matchAll(THINK_TAG_RE)) {
+        const idx = match.index ?? 0;
+        const isClose = match[1] === "/";
+        if (inThink && isClose) {
+            parts.push(text.slice(lastIndex, idx));
+            inThink = false;
+        }
+        else if (!inThink && !isClose) {
+            inThink = true;
+            lastIndex = idx + match[0].length;
+        }
+    }
+    // Unclosed trailing block — keep what the model emitted.
+    if (inThink)
+        parts.push(text.slice(lastIndex));
+    return parts.join("\n").trim();
+}
+/**
+ * Split a raw agent reply into an optional reasoning message + the sanitized
+ * answer. The answer is identical to `sanitizeReplyForChannel(raw)`; the
+ * reasoning is only populated when a `<think>` block carried content.
+ */
+export function splitDiscordReasoning(raw) {
+    const answerText = sanitizeReplyForChannel(raw ?? "");
+    const reasoning = extractReasoning(raw ?? "");
+    if (!reasoning)
+        return { answerText };
+    return { reasoningText: `${REASONING_PREFIX}${reasoning}`, answerText };
+}
+//# sourceMappingURL=reasoning-lane.js.map

package/dist/agents/channels/discord/reasoning-lane.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reasoning-lane.js","sourceRoot":"","sources":["../../../../src/agents/channels/discord/reasoning-lane.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAC;AAEhE,6EAA6E;AAC7E,MAAM,CAAC,MAAM,gBAAgB,GAAG,iBAAiB,CAAC;AAElD,mEAAmE;AACnE,MAAM,YAAY,GAAG,kDAAkD,CAAC;AASxE;;;;GAIG;AACH,MAAM,UAAU,gBAAgB,CAAC,IAAY;IAC5C,IAAI,CAAC,IAAI;QAAE,OAAO,EAAE,CAAC;IACrB,MAAM,KAAK,GAAa,EAAE,CAAC;IAC3B,IAAI,OAAO,GAAG,KAAK,CAAC;IACpB,IAAI,SAAS,GAAG,CAAC,CAAC;IAClB,YAAY,CAAC,SAAS,GAAG,CAAC,CAAC;IAC3B,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,EAAE,CAAC;QACjD,MAAM,GAAG,GAAG,KAAK,CAAC,KAAK,IAAI,CAAC,CAAC;QAC7B,MAAM,OAAO,GAAG,KAAK,CAAC,CAAC,CAAC,KAAK,GAAG,CAAC;QACjC,IAAI,OAAO,IAAI,OAAO,EAAE,CAAC;YACxB,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,GAAG,CAAC,CAAC,CAAC;YACvC,OAAO,GAAG,KAAK,CAAC;QACjB,CAAC;aAAM,IAAI,CAAC,OAAO,IAAI,CAAC,OAAO,EAAE,CAAC;YACjC,OAAO,GAAG,IAAI,CAAC;YACf,SAAS,GAAG,GAAG,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC;QACnC,CAAC;IACF,CAAC;IACD,yDAAyD;IACzD,IAAI,OAAO;QAAE,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC;IAC/C,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,CAAC;AAChC,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,qBAAqB,CAAC,GAAW;IAChD,MAAM,UAAU,GAAG,uBAAuB,CAAC,GAAG,IAAI,EAAE,CAAC,CAAC;IACtD,MAAM,SAAS,GAAG,gBAAgB,CAAC,GAAG,IAAI,EAAE,CAAC,CAAC;IAC9C,IAAI,CAAC,SAAS;QAAE,OAAO,EAAE,UAAU,EAAE,CAAC;IACtC,OAAO,EAAE,aAAa,EAAE,GAAG,gBAAgB,GAAG,SAAS,EAAE,EAAE,UAAU,EAAE,CAAC;AACzE,CAAC"}

package/dist/agents/channels/discord/rest-actions.d.ts

@@ -0,0 +1,346 @@
+/**
+ * Discord REST v10 action helpers — the self-contained REST surface behind the
+ * `discord_action` agent tool.
+ *
+ * Mirrors `probe.ts`: every helper talks to `https://discord.com/api/v10/...`
+ * over plain HTTPS with the `Authorization: Bot <token>` header — NO `discord.js`,
+ * NO Gateway socket, NO live adapter/connection. The bot token is resolved by the
+ * tool (via `resolveDiscordBotToken`) and threaded in; it rides only in the
+ * `Authorization` header, built locally and never logged.
+ *
+ * `fetch` is INJECTABLE (defaults to global fetch) so tests can stub the call and
+ * assert the exact METHOD + PATH + body without touching the network.
+ *
+ * The action surface here matches the guild capability set Brigade's live adapter
+ * lacks: messaging/content (send, embeds, polls, stickers, reads, reactions,
+ * threads, search), guild-admin (channels, categories, roles, members, emojis,
+ * stickers, scheduled events), and moderation (ban/unban/kick/timeout). Each
+ * helper returns the parsed Discord JSON (or `{ ok: true }` for empty 204s); REST
+ * failures throw a {@link DiscordRestError} carrying the decoded Discord JSON code
+ * so the tool can render an operator-readable message (permissions / 404 / rate
+ * limit).
+ */
+/** A REST call that came back non-2xx. Carries the HTTP status + decoded Discord code. */
+export declare class DiscordRestError extends Error {
+    readonly status: number;
+    /** The Discord JSON error `code` (stable across endpoints), when present. */
+    readonly code?: number;
+    /** Retry-after seconds, populated on a 429 rate-limit. */
+    readonly retryAfter?: number;
+    constructor(message: string, opts: {
+        status: number;
+        code?: number;
+        retryAfter?: number;
+    });
+}
+/**
+ * Turn a non-2xx Discord REST response into an operator-readable {@link DiscordRestError}.
+ * Decodes the Discord JSON `code` into a remediation hint for the actionable cases
+ * (permissions 50013, missing access 50001, DM-blocked 50007, unknown-resource
+ * 100xx, rate-limit 429); everything else surfaces the raw Discord `message`.
+ */
+export declare function decodeDiscordRestError(status: number, body: unknown): DiscordRestError;
+/** Options every REST helper accepts: the resolved token + an injectable fetch. */
+export interface DiscordRestOptions {
+    /** The resolved bot token (Bot-prefix tolerated; stripped here). NEVER logged. */
+    token: string;
+    /** Injectable fetch — defaults to global fetch; tests pass a stub. */
+    fetchImpl?: typeof fetch;
+    /** Request timeout in ms (default 12s). */
+    timeoutMs?: number;
+}
+interface RequestInput {
+    method: "GET" | "POST" | "PATCH" | "PUT" | "DELETE";
+    /** Path under `/api/v10` (leading slash required), e.g. `/channels/123/messages`. */
+    path: string;
+    /** JSON body (object) — serialized + sent with a JSON content-type. Omit for GET/DELETE. */
+    body?: unknown;
+    /** Audit-log reason → `X-Audit-Log-Reason` header (moderation actions use it). */
+    reason?: string;
+    /** Query params appended to the path. */
+    query?: Record<string, string | number | undefined>;
+}
+/**
+ * Make one Discord REST call. Returns the parsed JSON (or `{ ok: true }` for an
+ * empty 204). Non-2xx throws a decoded {@link DiscordRestError}. Aborts after
+ * `timeoutMs`. The token rides only in the `Authorization` header.
+ */
+export declare function discordRestRequest(input: RequestInput, opts: DiscordRestOptions): Promise<unknown>;
+/** A rich-embed spec the model can pass to `send` / `send-embed`. All fields optional. */
+export interface DiscordEmbedSpec {
+    title?: string;
+    description?: string;
+    /** Decimal color int (e.g. 0x5865f2 = 5793266). */
+    color?: number;
+    url?: string;
+    fields?: Array<{
+        name: string;
+        value: string;
+        inline?: boolean;
+    }>;
+    footer?: string;
+    image?: string;
+    thumbnail?: string;
+}
+/** Build a Discord embed object from a {@link DiscordEmbedSpec} (drops empty fields). */
+export declare function buildEmbed(spec: DiscordEmbedSpec): Record<string, unknown>;
+/**
+ * Resolve a `to` target to a channel id for the messaging endpoints. A bare
+ * snowflake is used directly as a channel id. A `user:<id>` target opens (or
+ * reuses) a DM channel via `POST /users/@me/channels` and returns that id, so the
+ * agent can DM a user by id without knowing the DM channel id. A `channel:<id>`
+ * prefix is accepted and stripped.
+ */
+export declare function resolveSendChannelId(to: string, opts: DiscordRestOptions): Promise<string>;
+/**
+ * The wire-shape `allowed_mentions` Discord expects (snake_case). Mirrors the
+ * connection-path {@link safeDiscordAllowedMentions}: `parse` whitelists which
+ * mention CLASSES notify; omitting `"everyone"` is what kills the `@everyone` /
+ * `@here` mass-ping vector.
+ */
+export interface DiscordRestAllowedMentions {
+    parse?: Array<"users" | "roles" | "everyone">;
+    users?: string[];
+    roles?: string[];
+    replied_user?: boolean;
+}
+/**
+ * The SAFE default `allowed_mentions` applied to every REST send body. Matches the
+ * connection-path safety: `parse: ["users", "roles"]` lets explicit `<@id>` /
+ * `<@&roleid>` mentions ping, while the absence of `"everyone"` means an
+ * `@everyone` / `@here` that slipped into the content renders as inert text and
+ * pings no one. A fresh object per call so a send can't mutate the shared default.
+ */
+export declare function safeRestAllowedMentions(): DiscordRestAllowedMentions;
+export declare function sendMessage(params: {
+    to: string;
+    content?: string;
+    embeds?: DiscordEmbedSpec[];
+    components?: unknown[];
+    replyTo?: string;
+    silent?: boolean;
+    /**
+     * Extra message flags to OR in (e.g. the Components-V2 flag 1<<15). The
+     * silent flag is added on top of these. A V2 message must NOT carry plain
+     * `content` — the caller moves text into TextDisplay blocks.
+     */
+    flags?: number;
+    /**
+     * Opt-in `allowed_mentions` override. Omit for the SAFE default (users + roles,
+     * NO everyone) so `@everyone` in `content` can't mass-ping; pass an explicit
+     * shape only for a deliberate, owner-authorized broadcast.
+     */
+    allowedMentions?: DiscordRestAllowedMentions;
+}, opts: DiscordRestOptions): Promise<unknown>;
+export declare function sendEmbed(params: {
+    to: string;
+    embed: DiscordEmbedSpec;
+    content?: string;
+    allowedMentions?: DiscordRestAllowedMentions;
+}, opts: DiscordRestOptions): Promise<unknown>;
+export declare function sendPoll(params: {
+    to: string;
+    question: string;
+    answers: string[];
+    durationHours?: number;
+    allowMultiselect?: boolean;
+    allowedMentions?: DiscordRestAllowedMentions;
+}, opts: DiscordRestOptions): Promise<unknown>;
+export declare function sendSticker(params: {
+    to: string;
+    stickerIds: string[];
+    content?: string;
+    allowedMentions?: DiscordRestAllowedMentions;
+}, opts: DiscordRestOptions): Promise<unknown>;
+/** Fetch the most recent messages from a channel (capped at 50). */
+export declare function readMessages(params: {
+    channelId: string;
+    limit?: number;
+    before?: string;
+    after?: string;
+    around?: string;
+}, opts: DiscordRestOptions): Promise<unknown>;
+/** Who reacted with a given emoji (capped at 50). `emoji` is the raw unicode or `name:id`. */
+export declare function listReactions(params: {
+    channelId: string;
+    messageId: string;
+    emoji: string;
+    limit?: number;
+}, opts: DiscordRestOptions): Promise<unknown>;
+/** Remove the bot's own reaction (or, with `userId`, another user's). */
+export declare function removeReaction(params: {
+    channelId: string;
+    messageId: string;
+    emoji: string;
+    userId?: string;
+}, opts: DiscordRestOptions): Promise<unknown>;
+/** Create a thread — from a message (when `messageId` given) or standalone/forum. */
+export declare function threadCreate(params: {
+    channelId: string;
+    name: string;
+    messageId?: string;
+    autoArchiveMinutes?: number;
+    type?: number;
+    content?: string;
+}, opts: DiscordRestOptions): Promise<unknown>;
+/** List active threads in a guild (active threads endpoint). */
+export declare function listThreads(params: {
+    guildId: string;
+}, opts: DiscordRestOptions): Promise<unknown>;
+/** Guild message search (capped at 25). */
+export declare function searchMessages(params: {
+    guildId: string;
+    query: string;
+    authorId?: string;
+    channelId?: string;
+    limit?: number;
+}, opts: DiscordRestOptions): Promise<unknown>;
+export declare function channelCreate(params: {
+    guildId: string;
+    name: string;
+    type?: number;
+    parentId?: string;
+    topic?: string;
+    position?: number;
+    nsfw?: boolean;
+}, opts: DiscordRestOptions): Promise<unknown>;
+export declare function channelEdit(params: {
+    channelId: string;
+    name?: string;
+    topic?: string;
+    position?: number;
+    parentId?: string;
+    nsfw?: boolean;
+    rateLimitPerUser?: number;
+    archived?: boolean;
+    locked?: boolean;
+}, opts: DiscordRestOptions): Promise<unknown>;
+export declare function channelDelete(params: {
+    channelId: string;
+}, opts: DiscordRestOptions): Promise<unknown>;
+/** Move a channel (position + optional new parent) via the guild channel-positions endpoint. */
+export declare function channelMove(params: {
+    guildId: string;
+    channelId: string;
+    position?: number;
+    parentId?: string;
+}, opts: DiscordRestOptions): Promise<unknown>;
+/** Create a category (channel type 4). */
+export declare function categoryCreate(params: {
+    guildId: string;
+    name: string;
+    position?: number;
+}, opts: DiscordRestOptions): Promise<unknown>;
+export declare function categoryEdit(params: {
+    categoryId: string;
+    name?: string;
+    position?: number;
+}, opts: DiscordRestOptions): Promise<unknown>;
+export declare function categoryDelete(params: {
+    categoryId: string;
+}, opts: DiscordRestOptions): Promise<unknown>;
+export declare function roleList(params: {
+    guildId: string;
+}, opts: DiscordRestOptions): Promise<unknown>;
+export declare function roleAdd(params: {
+    guildId: string;
+    userId: string;
+    roleId: string;
+    reason?: string;
+}, opts: DiscordRestOptions): Promise<unknown>;
+export declare function roleRemove(params: {
+    guildId: string;
+    userId: string;
+    roleId: string;
+    reason?: string;
+}, opts: DiscordRestOptions): Promise<unknown>;
+/** Alias of {@link roleList} — surfaced as the `role-info` action. */
+export declare function roleInfo(params: {
+    guildId: string;
+}, opts: DiscordRestOptions): Promise<unknown>;
+export declare function memberInfo(params: {
+    guildId: string;
+    userId: string;
+}, opts: DiscordRestOptions): Promise<unknown>;
+export declare function emojiList(params: {
+    guildId: string;
+}, opts: DiscordRestOptions): Promise<unknown>;
+/** Upload a custom emoji. `image` MUST be a data URI (`data:image/png;base64,...`). */
+export declare function emojiUpload(params: {
+    guildId: string;
+    name: string;
+    image: string;
+    roleIds?: string[];
+}, opts: DiscordRestOptions): Promise<unknown>;
+/**
+ * Upload a guild sticker. Discord requires `multipart/form-data` here (the sticker
+ * file is a binary part), so this is the one helper that does NOT go through the
+ * JSON `discordRestRequest`. `file` is the raw bytes; `contentType` is the
+ * MIME type (image/png, image/apng, application/json for Lottie).
+ */
+export declare function stickerUpload(params: {
+    guildId: string;
+    name: string;
+    description: string;
+    tags: string;
+    file: Uint8Array;
+    contentType: string;
+    filename?: string;
+}, opts: DiscordRestOptions): Promise<unknown>;
+export declare function eventList(params: {
+    guildId: string;
+}, opts: DiscordRestOptions): Promise<unknown>;
+/**
+ * Create a guild scheduled event. `entityType`: 1=stage, 2=voice, 3=external.
+ * A voice/stage event needs `channelId`; an external event needs `location` +
+ * `endTime`. Times are ISO-8601 strings.
+ */
+export declare function eventCreate(params: {
+    guildId: string;
+    name: string;
+    startTime: string;
+    endTime?: string;
+    description?: string;
+    channelId?: string;
+    location?: string;
+    entityType?: "stage" | "voice" | "external";
+}, opts: DiscordRestOptions): Promise<unknown>;
+/**
+ * Ban a guild member. `deleteMessageDays` (0–7) purges their recent messages.
+ * Owner-only is the tool gate; Discord enforces the bot's own BAN_MEMBERS
+ * permission (a 50013 is decoded into a readable hint).
+ */
+export declare function ban(params: {
+    guildId: string;
+    userId: string;
+    reason?: string;
+    deleteMessageDays?: number;
+}, opts: DiscordRestOptions): Promise<unknown>;
+export declare function unban(params: {
+    guildId: string;
+    userId: string;
+    reason?: string;
+}, opts: DiscordRestOptions): Promise<unknown>;
+export declare function kick(params: {
+    guildId: string;
+    userId: string;
+    reason?: string;
+}, opts: DiscordRestOptions): Promise<unknown>;
+/**
+ * Time a member out for `durationMinutes` from now (max 28 days), or clear it with
+ * {@link untimeout}. Sets `communication_disabled_until` to an ISO timestamp.
+ */
+export declare function timeout(params: {
+    guildId: string;
+    userId: string;
+    durationMinutes: number;
+    reason?: string;
+}, opts: DiscordRestOptions): Promise<unknown>;
+/** Clear a member's timeout (sets `communication_disabled_until` to null). */
+export declare function untimeout(params: {
+    guildId: string;
+    userId: string;
+    reason?: string;
+}, opts: DiscordRestOptions): Promise<unknown>;
+export {};
+//# sourceMappingURL=rest-actions.d.ts.map