@intent-systems/nexus 2026.1.5-3

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

@@ -0,0 +1,141 @@
+import { Type } from "@sinclair/typebox";
+import { normalizeCronJobCreate, normalizeCronJobPatch, } from "../../cron/normalize.js";
+import { jsonResult, readStringParam } from "./common.js";
+import { callGatewayTool } from "./gateway.js";
+// NOTE: We use Type.Object({}, { additionalProperties: true }) for job/patch
+// instead of CronAddParamsSchema/CronJobPatchSchema because:
+//
+// 1. CronAddParamsSchema contains nested Type.Union (for schedule, payload, etc.)
+// 2. TypeBox compiles Type.Union to JSON Schema `anyOf`
+// 3. pi-ai's sanitizeSchemaForGoogle() strips `anyOf` from nested properties
+// 4. This leaves empty schemas `{}` which Claude rejects as invalid
+//
+// The actual validation happens at runtime via normalizeCronJobCreate/Patch
+// and the gateway's validateCronAddParams. This schema just needs to accept
+// any object so the AI can pass through the job definition.
+//
+// See: https://github.com/anthropics/anthropic-cookbook/blob/main/misc/tool_use_best_practices.md
+// Claude requires valid JSON Schema 2020-12 with explicit types.
+const CronToolSchema = Type.Union([
+    Type.Object({
+        action: Type.Literal("status"),
+        gatewayUrl: Type.Optional(Type.String()),
+        gatewayToken: Type.Optional(Type.String()),
+        timeoutMs: Type.Optional(Type.Number()),
+    }),
+    Type.Object({
+        action: Type.Literal("list"),
+        gatewayUrl: Type.Optional(Type.String()),
+        gatewayToken: Type.Optional(Type.String()),
+        timeoutMs: Type.Optional(Type.Number()),
+        includeDisabled: Type.Optional(Type.Boolean()),
+    }),
+    Type.Object({
+        action: Type.Literal("add"),
+        gatewayUrl: Type.Optional(Type.String()),
+        gatewayToken: Type.Optional(Type.String()),
+        timeoutMs: Type.Optional(Type.Number()),
+        job: Type.Object({}, { additionalProperties: true }),
+    }),
+    Type.Object({
+        action: Type.Literal("update"),
+        gatewayUrl: Type.Optional(Type.String()),
+        gatewayToken: Type.Optional(Type.String()),
+        timeoutMs: Type.Optional(Type.Number()),
+        id: Type.String(),
+        patch: Type.Object({}, { additionalProperties: true }),
+    }),
+    Type.Object({
+        action: Type.Literal("remove"),
+        gatewayUrl: Type.Optional(Type.String()),
+        gatewayToken: Type.Optional(Type.String()),
+        timeoutMs: Type.Optional(Type.Number()),
+        id: Type.String(),
+    }),
+    Type.Object({
+        action: Type.Literal("run"),
+        gatewayUrl: Type.Optional(Type.String()),
+        gatewayToken: Type.Optional(Type.String()),
+        timeoutMs: Type.Optional(Type.Number()),
+        id: Type.String(),
+    }),
+    Type.Object({
+        action: Type.Literal("runs"),
+        gatewayUrl: Type.Optional(Type.String()),
+        gatewayToken: Type.Optional(Type.String()),
+        timeoutMs: Type.Optional(Type.Number()),
+        id: Type.String(),
+    }),
+    Type.Object({
+        action: Type.Literal("wake"),
+        gatewayUrl: Type.Optional(Type.String()),
+        gatewayToken: Type.Optional(Type.String()),
+        timeoutMs: Type.Optional(Type.Number()),
+        text: Type.String(),
+        mode: Type.Optional(Type.Union([Type.Literal("now"), Type.Literal("next-heartbeat")])),
+    }),
+]);
+export function createCronTool() {
+    return {
+        label: "Cron",
+        name: "cron",
+        description: "Manage Gateway cron jobs (status/list/add/update/remove/run/runs) and send wake events.",
+        parameters: CronToolSchema,
+        execute: async (_toolCallId, args) => {
+            const params = args;
+            const action = readStringParam(params, "action", { required: true });
+            const gatewayOpts = {
+                gatewayUrl: readStringParam(params, "gatewayUrl", { trim: false }),
+                gatewayToken: readStringParam(params, "gatewayToken", { trim: false }),
+                timeoutMs: typeof params.timeoutMs === "number" ? params.timeoutMs : undefined,
+            };
+            switch (action) {
+                case "status":
+                    return jsonResult(await callGatewayTool("cron.status", gatewayOpts, {}));
+                case "list":
+                    return jsonResult(await callGatewayTool("cron.list", gatewayOpts, {
+                        includeDisabled: Boolean(params.includeDisabled),
+                    }));
+                case "add": {
+                    if (!params.job || typeof params.job !== "object") {
+                        throw new Error("job required");
+                    }
+                    const job = normalizeCronJobCreate(params.job) ?? params.job;
+                    return jsonResult(await callGatewayTool("cron.add", gatewayOpts, job));
+                }
+                case "update": {
+                    const id = readStringParam(params, "id", { required: true });
+                    if (!params.patch || typeof params.patch !== "object") {
+                        throw new Error("patch required");
+                    }
+                    const patch = normalizeCronJobPatch(params.patch) ?? params.patch;
+                    return jsonResult(await callGatewayTool("cron.update", gatewayOpts, {
+                        id,
+                        patch,
+                    }));
+                }
+                case "remove": {
+                    const id = readStringParam(params, "id", { required: true });
+                    return jsonResult(await callGatewayTool("cron.remove", gatewayOpts, { id }));
+                }
+                case "run": {
+                    const id = readStringParam(params, "id", { required: true });
+                    return jsonResult(await callGatewayTool("cron.run", gatewayOpts, { id }));
+                }
+                case "runs": {
+                    const id = readStringParam(params, "id", { required: true });
+                    return jsonResult(await callGatewayTool("cron.runs", gatewayOpts, { id }));
+                }
+                case "wake": {
+                    const text = readStringParam(params, "text", { required: true });
+                    const mode = params.mode === "now" || params.mode === "next-heartbeat"
+                        ? params.mode
+                        : "next-heartbeat";
+                    return jsonResult(await callGatewayTool("wake", gatewayOpts, { mode, text }, { expectFinal: false }));
+                }
+                default:
+                    throw new Error(`Unknown action: ${action}`);
+            }
+        },
+    };
+}

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

@@ -0,0 +1,186 @@
+import { addRoleDiscord, createScheduledEventDiscord, fetchChannelInfoDiscord, fetchMemberInfoDiscord, fetchRoleInfoDiscord, fetchVoiceStatusDiscord, listGuildChannelsDiscord, listGuildEmojisDiscord, listScheduledEventsDiscord, removeRoleDiscord, uploadEmojiDiscord, uploadStickerDiscord, } from "../../discord/send.js";
+import { jsonResult, readStringArrayParam, readStringParam } from "./common.js";
+export async function handleDiscordGuildAction(action, params, isActionEnabled) {
+    switch (action) {
+        case "memberInfo": {
+            if (!isActionEnabled("memberInfo")) {
+                throw new Error("Discord member info is disabled.");
+            }
+            const guildId = readStringParam(params, "guildId", {
+                required: true,
+            });
+            const userId = readStringParam(params, "userId", {
+                required: true,
+            });
+            const member = await fetchMemberInfoDiscord(guildId, userId);
+            return jsonResult({ ok: true, member });
+        }
+        case "roleInfo": {
+            if (!isActionEnabled("roleInfo")) {
+                throw new Error("Discord role info is disabled.");
+            }
+            const guildId = readStringParam(params, "guildId", {
+                required: true,
+            });
+            const roles = await fetchRoleInfoDiscord(guildId);
+            return jsonResult({ ok: true, roles });
+        }
+        case "emojiList": {
+            if (!isActionEnabled("reactions")) {
+                throw new Error("Discord reactions are disabled.");
+            }
+            const guildId = readStringParam(params, "guildId", {
+                required: true,
+            });
+            const emojis = await listGuildEmojisDiscord(guildId);
+            return jsonResult({ ok: true, emojis });
+        }
+        case "emojiUpload": {
+            if (!isActionEnabled("emojiUploads")) {
+                throw new Error("Discord emoji uploads are disabled.");
+            }
+            const guildId = readStringParam(params, "guildId", {
+                required: true,
+            });
+            const name = readStringParam(params, "name", { required: true });
+            const mediaUrl = readStringParam(params, "mediaUrl", {
+                required: true,
+            });
+            const roleIds = readStringArrayParam(params, "roleIds");
+            const emoji = await uploadEmojiDiscord({
+                guildId,
+                name,
+                mediaUrl,
+                roleIds: roleIds?.length ? roleIds : undefined,
+            });
+            return jsonResult({ ok: true, emoji });
+        }
+        case "stickerUpload": {
+            if (!isActionEnabled("stickerUploads")) {
+                throw new Error("Discord sticker uploads are disabled.");
+            }
+            const guildId = readStringParam(params, "guildId", {
+                required: true,
+            });
+            const name = readStringParam(params, "name", { required: true });
+            const description = readStringParam(params, "description", {
+                required: true,
+            });
+            const tags = readStringParam(params, "tags", { required: true });
+            const mediaUrl = readStringParam(params, "mediaUrl", {
+                required: true,
+            });
+            const sticker = await uploadStickerDiscord({
+                guildId,
+                name,
+                description,
+                tags,
+                mediaUrl,
+            });
+            return jsonResult({ ok: true, sticker });
+        }
+        case "roleAdd": {
+            if (!isActionEnabled("roles", false)) {
+                throw new Error("Discord role changes are disabled.");
+            }
+            const guildId = readStringParam(params, "guildId", {
+                required: true,
+            });
+            const userId = readStringParam(params, "userId", {
+                required: true,
+            });
+            const roleId = readStringParam(params, "roleId", { required: true });
+            await addRoleDiscord({ guildId, userId, roleId });
+            return jsonResult({ ok: true });
+        }
+        case "roleRemove": {
+            if (!isActionEnabled("roles", false)) {
+                throw new Error("Discord role changes are disabled.");
+            }
+            const guildId = readStringParam(params, "guildId", {
+                required: true,
+            });
+            const userId = readStringParam(params, "userId", {
+                required: true,
+            });
+            const roleId = readStringParam(params, "roleId", { required: true });
+            await removeRoleDiscord({ guildId, userId, roleId });
+            return jsonResult({ ok: true });
+        }
+        case "channelInfo": {
+            if (!isActionEnabled("channelInfo")) {
+                throw new Error("Discord channel info is disabled.");
+            }
+            const channelId = readStringParam(params, "channelId", {
+                required: true,
+            });
+            const channel = await fetchChannelInfoDiscord(channelId);
+            return jsonResult({ ok: true, channel });
+        }
+        case "channelList": {
+            if (!isActionEnabled("channelInfo")) {
+                throw new Error("Discord channel info is disabled.");
+            }
+            const guildId = readStringParam(params, "guildId", {
+                required: true,
+            });
+            const channels = await listGuildChannelsDiscord(guildId);
+            return jsonResult({ ok: true, channels });
+        }
+        case "voiceStatus": {
+            if (!isActionEnabled("voiceStatus")) {
+                throw new Error("Discord voice status is disabled.");
+            }
+            const guildId = readStringParam(params, "guildId", {
+                required: true,
+            });
+            const userId = readStringParam(params, "userId", {
+                required: true,
+            });
+            const voice = await fetchVoiceStatusDiscord(guildId, userId);
+            return jsonResult({ ok: true, voice });
+        }
+        case "eventList": {
+            if (!isActionEnabled("events")) {
+                throw new Error("Discord events are disabled.");
+            }
+            const guildId = readStringParam(params, "guildId", {
+                required: true,
+            });
+            const events = await listScheduledEventsDiscord(guildId);
+            return jsonResult({ ok: true, events });
+        }
+        case "eventCreate": {
+            if (!isActionEnabled("events")) {
+                throw new Error("Discord events are disabled.");
+            }
+            const guildId = readStringParam(params, "guildId", {
+                required: true,
+            });
+            const name = readStringParam(params, "name", { required: true });
+            const startTime = readStringParam(params, "startTime", {
+                required: true,
+            });
+            const endTime = readStringParam(params, "endTime");
+            const description = readStringParam(params, "description");
+            const channelId = readStringParam(params, "channelId");
+            const location = readStringParam(params, "location");
+            const entityTypeRaw = readStringParam(params, "entityType");
+            const entityType = entityTypeRaw === "stage" ? 1 : entityTypeRaw === "external" ? 3 : 2;
+            const payload = {
+                name,
+                description,
+                scheduled_start_time: startTime,
+                scheduled_end_time: endTime,
+                entity_type: entityType,
+                channel_id: channelId,
+                entity_metadata: entityType === 3 && location ? { location } : undefined,
+                privacy_level: 2,
+            };
+            const event = await createScheduledEventDiscord(guildId, payload);
+            return jsonResult({ ok: true, event });
+        }
+        default:
+            throw new Error(`Unknown action: ${action}`);
+    }
+}

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

@@ -0,0 +1,313 @@
+import { createThreadDiscord, deleteMessageDiscord, editMessageDiscord, fetchChannelPermissionsDiscord, fetchReactionsDiscord, listPinsDiscord, listThreadsDiscord, pinMessageDiscord, reactMessageDiscord, readMessagesDiscord, searchMessagesDiscord, sendMessageDiscord, sendPollDiscord, sendStickerDiscord, unpinMessageDiscord, } from "../../discord/send.js";
+import { jsonResult, readStringArrayParam, readStringParam } from "./common.js";
+function formatDiscordTimestamp(ts) {
+    if (!ts)
+        return undefined;
+    const date = new Date(ts);
+    if (Number.isNaN(date.getTime()))
+        return undefined;
+    const yyyy = String(date.getFullYear()).padStart(4, "0");
+    const mm = String(date.getMonth() + 1).padStart(2, "0");
+    const dd = String(date.getDate()).padStart(2, "0");
+    const hh = String(date.getHours()).padStart(2, "0");
+    const min = String(date.getMinutes()).padStart(2, "0");
+    // getTimezoneOffset() is minutes *behind* UTC. Flip sign to get ISO offset.
+    const offsetMinutes = -date.getTimezoneOffset();
+    const sign = offsetMinutes >= 0 ? "+" : "-";
+    const absOffsetMinutes = Math.abs(offsetMinutes);
+    const offsetH = String(Math.floor(absOffsetMinutes / 60)).padStart(2, "0");
+    const offsetM = String(absOffsetMinutes % 60).padStart(2, "0");
+    const tz = Intl.DateTimeFormat().resolvedOptions().timeZone;
+    const tzSuffix = tz ? `{${tz}}` : "";
+    // Compact ISO-like *local* timestamp with minutes precision.
+    // Example: 2025-01-02T03:04-08:00{America/Los_Angeles}
+    return `${yyyy}-${mm}-${dd}T${hh}:${min}${sign}${offsetH}:${offsetM}${tzSuffix}`;
+}
+export async function handleDiscordMessagingAction(action, params, isActionEnabled) {
+    switch (action) {
+        case "react": {
+            if (!isActionEnabled("reactions")) {
+                throw new Error("Discord reactions are disabled.");
+            }
+            const channelId = readStringParam(params, "channelId", {
+                required: true,
+            });
+            const messageId = readStringParam(params, "messageId", {
+                required: true,
+            });
+            const emoji = readStringParam(params, "emoji", { required: true });
+            await reactMessageDiscord(channelId, messageId, emoji);
+            return jsonResult({ ok: true });
+        }
+        case "reactions": {
+            if (!isActionEnabled("reactions")) {
+                throw new Error("Discord reactions are disabled.");
+            }
+            const channelId = readStringParam(params, "channelId", {
+                required: true,
+            });
+            const messageId = readStringParam(params, "messageId", {
+                required: true,
+            });
+            const limitRaw = params.limit;
+            const limit = typeof limitRaw === "number" && Number.isFinite(limitRaw)
+                ? limitRaw
+                : undefined;
+            const reactions = await fetchReactionsDiscord(channelId, messageId, {
+                limit,
+            });
+            return jsonResult({ ok: true, reactions });
+        }
+        case "sticker": {
+            if (!isActionEnabled("stickers")) {
+                throw new Error("Discord stickers are disabled.");
+            }
+            const to = readStringParam(params, "to", { required: true });
+            const content = readStringParam(params, "content");
+            const stickerIds = readStringArrayParam(params, "stickerIds", {
+                required: true,
+                label: "stickerIds",
+            });
+            await sendStickerDiscord(to, stickerIds, { content });
+            return jsonResult({ ok: true });
+        }
+        case "poll": {
+            if (!isActionEnabled("polls")) {
+                throw new Error("Discord polls are disabled.");
+            }
+            const to = readStringParam(params, "to", { required: true });
+            const content = readStringParam(params, "content");
+            const question = readStringParam(params, "question", {
+                required: true,
+            });
+            const answers = readStringArrayParam(params, "answers", {
+                required: true,
+                label: "answers",
+            });
+            const allowMultiselectRaw = params.allowMultiselect;
+            const allowMultiselect = typeof allowMultiselectRaw === "boolean"
+                ? allowMultiselectRaw
+                : undefined;
+            const durationRaw = params.durationHours;
+            const durationHours = typeof durationRaw === "number" && Number.isFinite(durationRaw)
+                ? durationRaw
+                : undefined;
+            const maxSelections = allowMultiselect ? Math.max(2, answers.length) : 1;
+            await sendPollDiscord(to, { question, options: answers, maxSelections, durationHours }, { content });
+            return jsonResult({ ok: true });
+        }
+        case "permissions": {
+            if (!isActionEnabled("permissions")) {
+                throw new Error("Discord permissions are disabled.");
+            }
+            const channelId = readStringParam(params, "channelId", {
+                required: true,
+            });
+            const permissions = await fetchChannelPermissionsDiscord(channelId);
+            return jsonResult({ ok: true, permissions });
+        }
+        case "readMessages": {
+            if (!isActionEnabled("messages")) {
+                throw new Error("Discord message reads are disabled.");
+            }
+            const channelId = readStringParam(params, "channelId", {
+                required: true,
+            });
+            const messages = await readMessagesDiscord(channelId, {
+                limit: typeof params.limit === "number" && Number.isFinite(params.limit)
+                    ? params.limit
+                    : undefined,
+                before: readStringParam(params, "before"),
+                after: readStringParam(params, "after"),
+                around: readStringParam(params, "around"),
+            });
+            const formattedMessages = messages.map((message) => ({
+                ...message,
+                timestamp: formatDiscordTimestamp(message.timestamp) ?? message.timestamp,
+            }));
+            return jsonResult({ ok: true, messages: formattedMessages });
+        }
+        case "sendMessage": {
+            if (!isActionEnabled("messages")) {
+                throw new Error("Discord message sends are disabled.");
+            }
+            const to = readStringParam(params, "to", { required: true });
+            const content = readStringParam(params, "content", {
+                required: true,
+            });
+            const mediaUrl = readStringParam(params, "mediaUrl");
+            const replyTo = readStringParam(params, "replyTo");
+            const result = await sendMessageDiscord(to, content, {
+                mediaUrl,
+                replyTo,
+            });
+            return jsonResult({ ok: true, result });
+        }
+        case "editMessage": {
+            if (!isActionEnabled("messages")) {
+                throw new Error("Discord message edits are disabled.");
+            }
+            const channelId = readStringParam(params, "channelId", {
+                required: true,
+            });
+            const messageId = readStringParam(params, "messageId", {
+                required: true,
+            });
+            const content = readStringParam(params, "content", {
+                required: true,
+            });
+            const message = await editMessageDiscord(channelId, messageId, {
+                content,
+            });
+            return jsonResult({ ok: true, message });
+        }
+        case "deleteMessage": {
+            if (!isActionEnabled("messages")) {
+                throw new Error("Discord message deletes are disabled.");
+            }
+            const channelId = readStringParam(params, "channelId", {
+                required: true,
+            });
+            const messageId = readStringParam(params, "messageId", {
+                required: true,
+            });
+            await deleteMessageDiscord(channelId, messageId);
+            return jsonResult({ ok: true });
+        }
+        case "threadCreate": {
+            if (!isActionEnabled("threads")) {
+                throw new Error("Discord threads are disabled.");
+            }
+            const channelId = readStringParam(params, "channelId", {
+                required: true,
+            });
+            const name = readStringParam(params, "name", { required: true });
+            const messageId = readStringParam(params, "messageId");
+            const autoArchiveMinutesRaw = params.autoArchiveMinutes;
+            const autoArchiveMinutes = typeof autoArchiveMinutesRaw === "number" &&
+                Number.isFinite(autoArchiveMinutesRaw)
+                ? autoArchiveMinutesRaw
+                : undefined;
+            const thread = await createThreadDiscord(channelId, {
+                name,
+                messageId,
+                autoArchiveMinutes,
+            });
+            return jsonResult({ ok: true, thread });
+        }
+        case "threadList": {
+            if (!isActionEnabled("threads")) {
+                throw new Error("Discord threads are disabled.");
+            }
+            const guildId = readStringParam(params, "guildId", {
+                required: true,
+            });
+            const channelId = readStringParam(params, "channelId");
+            const includeArchived = typeof params.includeArchived === "boolean"
+                ? params.includeArchived
+                : undefined;
+            const before = readStringParam(params, "before");
+            const limit = typeof params.limit === "number" && Number.isFinite(params.limit)
+                ? params.limit
+                : undefined;
+            const threads = await listThreadsDiscord({
+                guildId,
+                channelId,
+                includeArchived,
+                before,
+                limit,
+            });
+            return jsonResult({ ok: true, threads });
+        }
+        case "threadReply": {
+            if (!isActionEnabled("threads")) {
+                throw new Error("Discord threads are disabled.");
+            }
+            const channelId = readStringParam(params, "channelId", {
+                required: true,
+            });
+            const content = readStringParam(params, "content", {
+                required: true,
+            });
+            const mediaUrl = readStringParam(params, "mediaUrl");
+            const replyTo = readStringParam(params, "replyTo");
+            const result = await sendMessageDiscord(`channel:${channelId}`, content, {
+                mediaUrl,
+                replyTo,
+            });
+            return jsonResult({ ok: true, result });
+        }
+        case "pinMessage": {
+            if (!isActionEnabled("pins")) {
+                throw new Error("Discord pins are disabled.");
+            }
+            const channelId = readStringParam(params, "channelId", {
+                required: true,
+            });
+            const messageId = readStringParam(params, "messageId", {
+                required: true,
+            });
+            await pinMessageDiscord(channelId, messageId);
+            return jsonResult({ ok: true });
+        }
+        case "unpinMessage": {
+            if (!isActionEnabled("pins")) {
+                throw new Error("Discord pins are disabled.");
+            }
+            const channelId = readStringParam(params, "channelId", {
+                required: true,
+            });
+            const messageId = readStringParam(params, "messageId", {
+                required: true,
+            });
+            await unpinMessageDiscord(channelId, messageId);
+            return jsonResult({ ok: true });
+        }
+        case "listPins": {
+            if (!isActionEnabled("pins")) {
+                throw new Error("Discord pins are disabled.");
+            }
+            const channelId = readStringParam(params, "channelId", {
+                required: true,
+            });
+            const pins = await listPinsDiscord(channelId);
+            return jsonResult({ ok: true, pins });
+        }
+        case "searchMessages": {
+            if (!isActionEnabled("search")) {
+                throw new Error("Discord search is disabled.");
+            }
+            const guildId = readStringParam(params, "guildId", {
+                required: true,
+            });
+            const content = readStringParam(params, "content", {
+                required: true,
+            });
+            const channelId = readStringParam(params, "channelId");
+            const channelIds = readStringArrayParam(params, "channelIds");
+            const authorId = readStringParam(params, "authorId");
+            const authorIds = readStringArrayParam(params, "authorIds");
+            const limit = typeof params.limit === "number" && Number.isFinite(params.limit)
+                ? params.limit
+                : undefined;
+            const channelIdList = [
+                ...(channelIds ?? []),
+                ...(channelId ? [channelId] : []),
+            ];
+            const authorIdList = [
+                ...(authorIds ?? []),
+                ...(authorId ? [authorId] : []),
+            ];
+            const results = await searchMessagesDiscord({
+                guildId,
+                content,
+                channelIds: channelIdList.length ? channelIdList : undefined,
+                authorIds: authorIdList.length ? authorIdList : undefined,
+                limit,
+            });
+            return jsonResult({ ok: true, results });
+        }
+        default:
+            throw new Error(`Unknown action: ${action}`);
+    }
+}