@intent-systems/nexus 2026.1.5-3

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

@@ -0,0 +1,70 @@
+import { banMemberDiscord, kickMemberDiscord, timeoutMemberDiscord, } from "../../discord/send.js";
+import { jsonResult, readStringParam } from "./common.js";
+export async function handleDiscordModerationAction(action, params, isActionEnabled) {
+    switch (action) {
+        case "timeout": {
+            if (!isActionEnabled("moderation", false)) {
+                throw new Error("Discord moderation is disabled.");
+            }
+            const guildId = readStringParam(params, "guildId", {
+                required: true,
+            });
+            const userId = readStringParam(params, "userId", {
+                required: true,
+            });
+            const durationMinutes = typeof params.durationMinutes === "number" &&
+                Number.isFinite(params.durationMinutes)
+                ? params.durationMinutes
+                : undefined;
+            const until = readStringParam(params, "until");
+            const reason = readStringParam(params, "reason");
+            const member = await timeoutMemberDiscord({
+                guildId,
+                userId,
+                durationMinutes,
+                until,
+                reason,
+            });
+            return jsonResult({ ok: true, member });
+        }
+        case "kick": {
+            if (!isActionEnabled("moderation", false)) {
+                throw new Error("Discord moderation is disabled.");
+            }
+            const guildId = readStringParam(params, "guildId", {
+                required: true,
+            });
+            const userId = readStringParam(params, "userId", {
+                required: true,
+            });
+            const reason = readStringParam(params, "reason");
+            await kickMemberDiscord({ guildId, userId, reason });
+            return jsonResult({ ok: true });
+        }
+        case "ban": {
+            if (!isActionEnabled("moderation", false)) {
+                throw new Error("Discord moderation is disabled.");
+            }
+            const guildId = readStringParam(params, "guildId", {
+                required: true,
+            });
+            const userId = readStringParam(params, "userId", {
+                required: true,
+            });
+            const reason = readStringParam(params, "reason");
+            const deleteMessageDays = typeof params.deleteMessageDays === "number" &&
+                Number.isFinite(params.deleteMessageDays)
+                ? params.deleteMessageDays
+                : undefined;
+            await banMemberDiscord({
+                guildId,
+                userId,
+                reason,
+                deleteMessageDays,
+            });
+            return jsonResult({ ok: true });
+        }
+        default:
+            throw new Error(`Unknown action: ${action}`);
+    }
+}

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

@@ -0,0 +1,56 @@
+import { readStringParam } from "./common.js";
+import { handleDiscordGuildAction } from "./discord-actions-guild.js";
+import { handleDiscordMessagingAction } from "./discord-actions-messaging.js";
+import { handleDiscordModerationAction } from "./discord-actions-moderation.js";
+const messagingActions = new Set([
+    "react",
+    "reactions",
+    "sticker",
+    "poll",
+    "permissions",
+    "readMessages",
+    "sendMessage",
+    "editMessage",
+    "deleteMessage",
+    "threadCreate",
+    "threadList",
+    "threadReply",
+    "pinMessage",
+    "unpinMessage",
+    "listPins",
+    "searchMessages",
+]);
+const guildActions = new Set([
+    "memberInfo",
+    "roleInfo",
+    "emojiList",
+    "emojiUpload",
+    "stickerUpload",
+    "roleAdd",
+    "roleRemove",
+    "channelInfo",
+    "channelList",
+    "voiceStatus",
+    "eventList",
+    "eventCreate",
+]);
+const moderationActions = new Set(["timeout", "kick", "ban"]);
+export async function handleDiscordAction(params, cfg) {
+    const action = readStringParam(params, "action", { required: true });
+    const isActionEnabled = (key, defaultValue = true) => {
+        const value = cfg.discord?.actions?.[key];
+        if (value === undefined)
+            return defaultValue;
+        return value !== false;
+    };
+    if (messagingActions.has(action)) {
+        return await handleDiscordMessagingAction(action, params, isActionEnabled);
+    }
+    if (guildActions.has(action)) {
+        return await handleDiscordGuildAction(action, params, isActionEnabled);
+    }
+    if (moderationActions.has(action)) {
+        return await handleDiscordModerationAction(action, params, isActionEnabled);
+    }
+    throw new Error(`Unknown action: ${action}`);
+}

package/dist/agents/tools/discord-schema.js

@@ -0,0 +1,199 @@
+import { Type } from "@sinclair/typebox";
+export const DiscordToolSchema = Type.Union([
+    Type.Object({
+        action: Type.Literal("react"),
+        channelId: Type.String(),
+        messageId: Type.String(),
+        emoji: Type.String(),
+    }),
+    Type.Object({
+        action: Type.Literal("reactions"),
+        channelId: Type.String(),
+        messageId: Type.String(),
+        limit: Type.Optional(Type.Number()),
+    }),
+    Type.Object({
+        action: Type.Literal("sticker"),
+        to: Type.String(),
+        stickerIds: Type.Array(Type.String()),
+        content: Type.Optional(Type.String()),
+    }),
+    Type.Object({
+        action: Type.Literal("poll"),
+        to: Type.String(),
+        question: Type.String(),
+        answers: Type.Array(Type.String()),
+        allowMultiselect: Type.Optional(Type.Boolean()),
+        durationHours: Type.Optional(Type.Number()),
+        content: Type.Optional(Type.String()),
+    }),
+    Type.Object({
+        action: Type.Literal("permissions"),
+        channelId: Type.String(),
+    }),
+    Type.Object({
+        action: Type.Literal("readMessages"),
+        channelId: Type.String(),
+        limit: Type.Optional(Type.Number()),
+        before: Type.Optional(Type.String()),
+        after: Type.Optional(Type.String()),
+        around: Type.Optional(Type.String()),
+    }),
+    Type.Object({
+        action: Type.Literal("sendMessage"),
+        to: Type.String(),
+        content: Type.String(),
+        mediaUrl: Type.Optional(Type.String()),
+        replyTo: Type.Optional(Type.String()),
+    }),
+    Type.Object({
+        action: Type.Literal("editMessage"),
+        channelId: Type.String(),
+        messageId: Type.String(),
+        content: Type.String(),
+    }),
+    Type.Object({
+        action: Type.Literal("deleteMessage"),
+        channelId: Type.String(),
+        messageId: Type.String(),
+    }),
+    Type.Object({
+        action: Type.Literal("threadCreate"),
+        channelId: Type.String(),
+        name: Type.String(),
+        messageId: Type.Optional(Type.String()),
+        autoArchiveMinutes: Type.Optional(Type.Number()),
+    }),
+    Type.Object({
+        action: Type.Literal("threadList"),
+        guildId: Type.String(),
+        channelId: Type.Optional(Type.String()),
+        includeArchived: Type.Optional(Type.Boolean()),
+        before: Type.Optional(Type.String()),
+        limit: Type.Optional(Type.Number()),
+    }),
+    Type.Object({
+        action: Type.Literal("threadReply"),
+        channelId: Type.String(),
+        content: Type.String(),
+        mediaUrl: Type.Optional(Type.String()),
+        replyTo: Type.Optional(Type.String()),
+    }),
+    Type.Object({
+        action: Type.Literal("pinMessage"),
+        channelId: Type.String(),
+        messageId: Type.String(),
+    }),
+    Type.Object({
+        action: Type.Literal("unpinMessage"),
+        channelId: Type.String(),
+        messageId: Type.String(),
+    }),
+    Type.Object({
+        action: Type.Literal("listPins"),
+        channelId: Type.String(),
+    }),
+    Type.Object({
+        action: Type.Literal("searchMessages"),
+        guildId: Type.String(),
+        content: Type.String(),
+        channelId: Type.Optional(Type.String()),
+        channelIds: Type.Optional(Type.Array(Type.String())),
+        authorId: Type.Optional(Type.String()),
+        authorIds: Type.Optional(Type.Array(Type.String())),
+        limit: Type.Optional(Type.Number()),
+    }),
+    Type.Object({
+        action: Type.Literal("memberInfo"),
+        guildId: Type.String(),
+        userId: Type.String(),
+    }),
+    Type.Object({
+        action: Type.Literal("roleInfo"),
+        guildId: Type.String(),
+    }),
+    Type.Object({
+        action: Type.Literal("emojiList"),
+        guildId: Type.String(),
+    }),
+    Type.Object({
+        action: Type.Literal("emojiUpload"),
+        guildId: Type.String(),
+        name: Type.String(),
+        mediaUrl: Type.String(),
+        roleIds: Type.Optional(Type.Array(Type.String())),
+    }),
+    Type.Object({
+        action: Type.Literal("stickerUpload"),
+        guildId: Type.String(),
+        name: Type.String(),
+        description: Type.String(),
+        tags: Type.String(),
+        mediaUrl: Type.String(),
+    }),
+    Type.Object({
+        action: Type.Literal("roleAdd"),
+        guildId: Type.String(),
+        userId: Type.String(),
+        roleId: Type.String(),
+    }),
+    Type.Object({
+        action: Type.Literal("roleRemove"),
+        guildId: Type.String(),
+        userId: Type.String(),
+        roleId: Type.String(),
+    }),
+    Type.Object({
+        action: Type.Literal("channelInfo"),
+        channelId: Type.String(),
+    }),
+    Type.Object({
+        action: Type.Literal("channelList"),
+        guildId: Type.String(),
+    }),
+    Type.Object({
+        action: Type.Literal("voiceStatus"),
+        guildId: Type.String(),
+        userId: Type.String(),
+    }),
+    Type.Object({
+        action: Type.Literal("eventList"),
+        guildId: Type.String(),
+    }),
+    Type.Object({
+        action: Type.Literal("eventCreate"),
+        guildId: Type.String(),
+        name: Type.String(),
+        startTime: Type.String(),
+        endTime: Type.Optional(Type.String()),
+        description: Type.Optional(Type.String()),
+        channelId: Type.Optional(Type.String()),
+        entityType: Type.Optional(Type.Union([
+            Type.Literal("voice"),
+            Type.Literal("stage"),
+            Type.Literal("external"),
+        ])),
+        location: Type.Optional(Type.String()),
+    }),
+    Type.Object({
+        action: Type.Literal("timeout"),
+        guildId: Type.String(),
+        userId: Type.String(),
+        durationMinutes: Type.Optional(Type.Number()),
+        until: Type.Optional(Type.String()),
+        reason: Type.Optional(Type.String()),
+    }),
+    Type.Object({
+        action: Type.Literal("kick"),
+        guildId: Type.String(),
+        userId: Type.String(),
+        reason: Type.Optional(Type.String()),
+    }),
+    Type.Object({
+        action: Type.Literal("ban"),
+        guildId: Type.String(),
+        userId: Type.String(),
+        reason: Type.Optional(Type.String()),
+        deleteMessageDays: Type.Optional(Type.Number()),
+    }),
+]);

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

@@ -0,0 +1,16 @@
+import { loadConfig } from "../../config/config.js";
+import { handleDiscordAction } from "./discord-actions.js";
+import { DiscordToolSchema } from "./discord-schema.js";
+export function createDiscordTool() {
+    return {
+        label: "Discord",
+        name: "discord",
+        description: "Manage Discord messages, reactions, and moderation.",
+        parameters: DiscordToolSchema,
+        execute: async (_toolCallId, args) => {
+            const params = args;
+            const cfg = loadConfig();
+            return await handleDiscordAction(params, cfg);
+        },
+    };
+}

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

@@ -0,0 +1,46 @@
+import { Type } from "@sinclair/typebox";
+import { jsonResult, readStringParam } from "./common.js";
+const GatewayToolSchema = Type.Union([
+    Type.Object({
+        action: Type.Literal("restart"),
+        delayMs: Type.Optional(Type.Number()),
+        reason: Type.Optional(Type.String()),
+    }),
+]);
+export function createGatewayTool() {
+    return {
+        label: "Gateway",
+        name: "gateway",
+        description: "Restart the running gateway process in-place (SIGUSR1) without needing an external supervisor. Use delayMs to avoid interrupting an in-flight reply.",
+        parameters: GatewayToolSchema,
+        execute: async (_toolCallId, args) => {
+            const params = args;
+            const action = readStringParam(params, "action", { required: true });
+            if (action !== "restart")
+                throw new Error(`Unknown action: ${action}`);
+            const delayMsRaw = typeof params.delayMs === "number" && Number.isFinite(params.delayMs)
+                ? Math.floor(params.delayMs)
+                : 2000;
+            const delayMs = Math.min(Math.max(delayMsRaw, 0), 60_000);
+            const reason = typeof params.reason === "string" && params.reason.trim()
+                ? params.reason.trim().slice(0, 200)
+                : undefined;
+            const pid = process.pid;
+            setTimeout(() => {
+                try {
+                    process.kill(pid, "SIGUSR1");
+                }
+                catch {
+                    /* ignore */
+                }
+            }, delayMs);
+            return jsonResult({
+                ok: true,
+                pid,
+                signal: "SIGUSR1",
+                delayMs,
+                reason: reason ?? null,
+            });
+        },
+    };
+}

package/dist/agents/tools/gateway.js

@@ -0,0 +1,28 @@
+import { callGateway } from "../../gateway/call.js";
+export const DEFAULT_GATEWAY_URL = "ws://127.0.0.1:18789";
+export function resolveGatewayOptions(opts) {
+    // Prefer an explicit override; otherwise let callGateway choose based on config.
+    const url = typeof opts?.gatewayUrl === "string" && opts.gatewayUrl.trim()
+        ? opts.gatewayUrl.trim()
+        : undefined;
+    const token = typeof opts?.gatewayToken === "string" && opts.gatewayToken.trim()
+        ? opts.gatewayToken.trim()
+        : undefined;
+    const timeoutMs = typeof opts?.timeoutMs === "number" && Number.isFinite(opts.timeoutMs)
+        ? Math.max(1, Math.floor(opts.timeoutMs))
+        : 10_000;
+    return { url, token, timeoutMs };
+}
+export async function callGatewayTool(method, opts, params, extra) {
+    const gateway = resolveGatewayOptions(opts);
+    return await callGateway({
+        url: gateway.url,
+        token: gateway.token,
+        method,
+        params,
+        timeoutMs: gateway.timeoutMs,
+        expectFinal: extra?.expectFinal,
+        clientName: "agent",
+        mode: "agent",
+    });
+}

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

@@ -0,0 +1,140 @@
+import { complete, } from "@mariozechner/pi-ai";
+import { discoverAuthStorage, discoverModels, } from "@mariozechner/pi-coding-agent";
+import { Type } from "@sinclair/typebox";
+import { resolveUserPath } from "../../utils.js";
+import { loadWebMedia } from "../../web/media.js";
+import { getApiKeyForModel } from "../model-auth.js";
+import { runWithImageModelFallback } from "../model-fallback.js";
+import { ensureNexusModelsJson } from "../models-config.js";
+import { extractAssistantText } from "../pi-embedded-utils.js";
+const DEFAULT_PROMPT = "Describe the image.";
+function ensureImageToolConfigured(cfg) {
+    const imageModel = cfg?.agent?.imageModel;
+    const primary = typeof imageModel === "string" ? imageModel.trim() : imageModel?.primary;
+    const fallbacks = typeof imageModel === "object" ? (imageModel?.fallbacks ?? []) : [];
+    return Boolean(primary?.trim() || fallbacks.length > 0);
+}
+function pickMaxBytes(cfg, maxBytesMb) {
+    if (typeof maxBytesMb === "number" &&
+        Number.isFinite(maxBytesMb) &&
+        maxBytesMb > 0) {
+        return Math.floor(maxBytesMb * 1024 * 1024);
+    }
+    const configured = cfg?.agent?.mediaMaxMb;
+    if (typeof configured === "number" &&
+        Number.isFinite(configured) &&
+        configured > 0) {
+        return Math.floor(configured * 1024 * 1024);
+    }
+    return undefined;
+}
+function buildImageContext(prompt, base64, mimeType) {
+    return {
+        messages: [
+            {
+                role: "user",
+                content: [
+                    { type: "text", text: prompt },
+                    { type: "image", data: base64, mimeType },
+                ],
+                timestamp: Date.now(),
+            },
+        ],
+    };
+}
+async function runImagePrompt(params) {
+    await ensureNexusModelsJson(params.cfg, params.agentDir);
+    const authStorage = discoverAuthStorage(params.agentDir);
+    const modelRegistry = discoverModels(authStorage, params.agentDir);
+    const result = await runWithImageModelFallback({
+        cfg: params.cfg,
+        modelOverride: params.modelOverride,
+        run: async (provider, modelId) => {
+            const model = modelRegistry.find(provider, modelId);
+            if (!model) {
+                throw new Error(`Unknown model: ${provider}/${modelId}`);
+            }
+            if (!model.input?.includes("image")) {
+                throw new Error(`Model does not support images: ${provider}/${modelId}`);
+            }
+            const apiKeyInfo = await getApiKeyForModel({
+                model,
+                cfg: params.cfg,
+                agentDir: params.agentDir,
+            });
+            authStorage.setRuntimeApiKey(model.provider, apiKeyInfo.apiKey);
+            const context = buildImageContext(params.prompt, params.base64, params.mimeType);
+            const message = (await complete(model, context, {
+                apiKey: apiKeyInfo.apiKey,
+                maxTokens: 512,
+                temperature: 0,
+            }));
+            return message;
+        },
+    });
+    const text = extractAssistantText(result.result);
+    return {
+        text: text || "(no text returned)",
+        provider: result.provider,
+        model: result.model,
+    };
+}
+export function createImageTool(options) {
+    if (!ensureImageToolConfigured(options?.config))
+        return null;
+    const agentDir = options?.agentDir;
+    if (!agentDir?.trim()) {
+        throw new Error("createImageTool requires agentDir when enabled");
+    }
+    return {
+        label: "Image",
+        name: "image",
+        description: "Analyze an image with the configured image model (agent.imageModel). Provide a prompt and image path or URL.",
+        parameters: Type.Object({
+            prompt: Type.Optional(Type.String()),
+            image: Type.String(),
+            model: Type.Optional(Type.String()),
+            maxBytesMb: Type.Optional(Type.Number()),
+        }),
+        execute: async (_toolCallId, args) => {
+            const record = args && typeof args === "object"
+                ? args
+                : {};
+            const imageRaw = typeof record.image === "string" ? record.image.trim() : "";
+            if (!imageRaw)
+                throw new Error("image required");
+            const promptRaw = typeof record.prompt === "string" && record.prompt.trim()
+                ? record.prompt.trim()
+                : DEFAULT_PROMPT;
+            const modelOverride = typeof record.model === "string" && record.model.trim()
+                ? record.model.trim()
+                : undefined;
+            const maxBytesMb = typeof record.maxBytesMb === "number" ? record.maxBytesMb : undefined;
+            const maxBytes = pickMaxBytes(options?.config, maxBytesMb);
+            const resolvedImage = imageRaw.startsWith("~")
+                ? resolveUserPath(imageRaw)
+                : imageRaw;
+            const media = await loadWebMedia(resolvedImage, maxBytes);
+            if (media.kind !== "image") {
+                throw new Error(`Unsupported media type: ${media.kind}`);
+            }
+            const mimeType = media.contentType ?? "image/png";
+            const base64 = media.buffer.toString("base64");
+            const result = await runImagePrompt({
+                cfg: options?.config,
+                agentDir,
+                modelOverride,
+                prompt: promptRaw,
+                base64,
+                mimeType,
+            });
+            return {
+                content: [{ type: "text", text: result.text }],
+                details: {
+                    model: `${result.provider}/${result.model}`,
+                    image: resolvedImage,
+                },
+            };
+        },
+    };
+}

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

@@ -0,0 +1,92 @@
+import { Type } from "@sinclair/typebox";
+import { getMemorySearchManager } from "../../memory/index.js";
+import { normalizeAgentId, resolveAgentIdFromSessionKey } from "../../routing/session-key.js";
+import { resolveMemorySearchConfig } from "../memory-search.js";
+import { jsonResult, readNumberParam, readStringParam } from "./common.js";
+const MemorySearchSchema = Type.Object({
+    query: Type.String(),
+    maxResults: Type.Optional(Type.Number()),
+    minScore: Type.Optional(Type.Number()),
+});
+const MemoryGetSchema = Type.Object({
+    path: Type.String(),
+    from: Type.Optional(Type.Number()),
+    lines: Type.Optional(Type.Number()),
+});
+function resolveToolAgentId(cfg, sessionKey) {
+    const rawSessionKey = sessionKey?.trim();
+    if (rawSessionKey) {
+        return resolveAgentIdFromSessionKey(rawSessionKey);
+    }
+    return normalizeAgentId(cfg.routing?.defaultAgentId);
+}
+export function createMemorySearchTool(options) {
+    const cfg = options.config;
+    if (!cfg)
+        return null;
+    const agentId = resolveToolAgentId(cfg, options.agentSessionKey);
+    if (!resolveMemorySearchConfig(cfg, agentId))
+        return null;
+    return {
+        label: "Memory Search",
+        name: "memory_search",
+        description: "Mandatory recall step: semantically search MEMORY.md + memory/*.md before answering questions about prior work, decisions, dates, people, preferences, or todos; returns top snippets with path + lines.",
+        parameters: MemorySearchSchema,
+        execute: async (_toolCallId, params) => {
+            const query = readStringParam(params, "query", { required: true });
+            const maxResults = readNumberParam(params, "maxResults");
+            const minScore = readNumberParam(params, "minScore");
+            const { manager, error } = await getMemorySearchManager({
+                cfg,
+                agentId,
+            });
+            if (!manager) {
+                return jsonResult({ results: [], disabled: true, error });
+            }
+            const results = await manager.search(query, {
+                maxResults,
+                minScore,
+                sessionKey: options.agentSessionKey,
+            });
+            const status = manager.status();
+            return jsonResult({
+                results,
+                provider: status.provider,
+                model: status.model,
+                fallback: status.fallback,
+            });
+        },
+    };
+}
+export function createMemoryGetTool(options) {
+    const cfg = options.config;
+    if (!cfg)
+        return null;
+    const agentId = resolveToolAgentId(cfg, options.agentSessionKey);
+    if (!resolveMemorySearchConfig(cfg, agentId))
+        return null;
+    return {
+        label: "Memory Get",
+        name: "memory_get",
+        description: "Safe snippet read from MEMORY.md or memory/*.md with optional from/lines; use after memory_search to pull only the needed lines and keep context small.",
+        parameters: MemoryGetSchema,
+        execute: async (_toolCallId, params) => {
+            const relPath = readStringParam(params, "path", { required: true });
+            const from = readNumberParam(params, "from", { integer: true });
+            const lines = readNumberParam(params, "lines", { integer: true });
+            const { manager, error } = await getMemorySearchManager({
+                cfg,
+                agentId,
+            });
+            if (!manager) {
+                return jsonResult({ path: relPath, text: "", disabled: true, error });
+            }
+            const result = await manager.readFile({
+                relPath,
+                from: from ?? undefined,
+                lines: lines ?? undefined,
+            });
+            return jsonResult(result);
+        },
+    };
+}