@intent-systems/nexus 2026.1.5-3

package/dist/gateway/server-methods/chat.js

@@ -0,0 +1,207 @@
+import { randomUUID } from "node:crypto";
+import { resolveThinkingDefault } from "../../agents/model-selection.js";
+import { resolveAgentTimeoutMs } from "../../agents/timeout.js";
+import { agentCommand } from "../../commands/agent.js";
+import { saveSessionStore } from "../../config/sessions.js";
+import { registerAgentRunContext } from "../../infra/agent-events.js";
+import { defaultRuntime } from "../../runtime.js";
+import { resolveSendPolicy } from "../../sessions/send-policy.js";
+import { buildMessageWithAttachments } from "../chat-attachments.js";
+import { ErrorCodes, errorShape, formatValidationErrors, validateChatAbortParams, validateChatHistoryParams, validateChatSendParams, } from "../protocol/index.js";
+import { MAX_CHAT_HISTORY_MESSAGES_BYTES } from "../server-constants.js";
+import { capArrayByJsonBytes, loadSessionEntry, readSessionMessages, resolveSessionModelRef, } from "../session-utils.js";
+import { formatForLog } from "../ws-log.js";
+export const chatHandlers = {
+    "chat.history": async ({ params, respond, context }) => {
+        if (!validateChatHistoryParams(params)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid chat.history params: ${formatValidationErrors(validateChatHistoryParams.errors)}`));
+            return;
+        }
+        const { sessionKey, limit } = params;
+        const { cfg, storePath, entry } = loadSessionEntry(sessionKey);
+        const sessionId = entry?.sessionId;
+        const rawMessages = sessionId && storePath ? readSessionMessages(sessionId, storePath) : [];
+        const hardMax = 1000;
+        const defaultLimit = 200;
+        const requested = typeof limit === "number" ? limit : defaultLimit;
+        const max = Math.min(hardMax, requested);
+        const sliced = rawMessages.length > max ? rawMessages.slice(-max) : rawMessages;
+        const capped = capArrayByJsonBytes(sliced, MAX_CHAT_HISTORY_MESSAGES_BYTES).items;
+        let thinkingLevel = entry?.thinkingLevel;
+        if (!thinkingLevel) {
+            const configured = cfg.agent?.thinkingDefault;
+            if (configured) {
+                thinkingLevel = configured;
+            }
+            else {
+                const { provider, model } = resolveSessionModelRef(cfg, entry);
+                const catalog = await context.loadGatewayModelCatalog();
+                thinkingLevel = resolveThinkingDefault({
+                    cfg,
+                    provider,
+                    model,
+                    catalog,
+                });
+            }
+        }
+        respond(true, {
+            sessionKey,
+            sessionId,
+            messages: capped,
+            thinkingLevel,
+        });
+    },
+    "chat.abort": ({ params, respond, context }) => {
+        if (!validateChatAbortParams(params)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid chat.abort params: ${formatValidationErrors(validateChatAbortParams.errors)}`));
+            return;
+        }
+        const { sessionKey, runId } = params;
+        const active = context.chatAbortControllers.get(runId);
+        if (!active) {
+            respond(true, { ok: true, aborted: false });
+            return;
+        }
+        if (active.sessionKey !== sessionKey) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, "runId does not match sessionKey"));
+            return;
+        }
+        active.controller.abort();
+        context.chatAbortControllers.delete(runId);
+        context.chatRunBuffers.delete(runId);
+        context.chatDeltaSentAt.delete(runId);
+        context.removeChatRun(runId, runId, sessionKey);
+        const payload = {
+            runId,
+            sessionKey,
+            seq: (context.agentRunSeq.get(runId) ?? 0) + 1,
+            state: "aborted",
+        };
+        context.broadcast("chat", payload);
+        context.bridgeSendToSession(sessionKey, "chat", payload);
+        respond(true, { ok: true, aborted: true });
+    },
+    "chat.send": async ({ params, respond, context }) => {
+        if (!validateChatSendParams(params)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid chat.send params: ${formatValidationErrors(validateChatSendParams.errors)}`));
+            return;
+        }
+        const p = params;
+        const normalizedAttachments = p.attachments?.map((a) => ({
+            type: typeof a?.type === "string" ? a.type : undefined,
+            mimeType: typeof a?.mimeType === "string" ? a.mimeType : undefined,
+            fileName: typeof a?.fileName === "string" ? a.fileName : undefined,
+            content: typeof a?.content === "string"
+                ? a.content
+                : ArrayBuffer.isView(a?.content)
+                    ? Buffer.from(a.content.buffer, a.content.byteOffset, a.content.byteLength).toString("base64")
+                    : undefined,
+        })) ?? [];
+        let messageWithAttachments = p.message;
+        if (normalizedAttachments.length > 0) {
+            try {
+                messageWithAttachments = buildMessageWithAttachments(p.message, normalizedAttachments, { maxBytes: 5_000_000 });
+            }
+            catch (err) {
+                respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, String(err)));
+                return;
+            }
+        }
+        const { cfg, storePath, store, entry } = loadSessionEntry(p.sessionKey);
+        const timeoutMs = resolveAgentTimeoutMs({
+            cfg,
+            overrideMs: p.timeoutMs,
+        });
+        const now = Date.now();
+        const sessionId = entry?.sessionId ?? randomUUID();
+        const sessionEntry = {
+            sessionId,
+            updatedAt: now,
+            thinkingLevel: entry?.thinkingLevel,
+            verboseLevel: entry?.verboseLevel,
+            systemSent: entry?.systemSent,
+            sendPolicy: entry?.sendPolicy,
+            lastProvider: entry?.lastProvider,
+            lastTo: entry?.lastTo,
+        };
+        const clientRunId = p.idempotencyKey;
+        registerAgentRunContext(clientRunId, { sessionKey: p.sessionKey });
+        const sendPolicy = resolveSendPolicy({
+            cfg,
+            entry,
+            sessionKey: p.sessionKey,
+            provider: entry?.provider,
+            chatType: entry?.chatType,
+        });
+        if (sendPolicy === "deny") {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, "send blocked by session policy"));
+            return;
+        }
+        const cached = context.dedupe.get(`chat:${clientRunId}`);
+        if (cached) {
+            respond(cached.ok, cached.payload, cached.error, {
+                cached: true,
+            });
+            return;
+        }
+        try {
+            const abortController = new AbortController();
+            context.chatAbortControllers.set(clientRunId, {
+                controller: abortController,
+                sessionId,
+                sessionKey: p.sessionKey,
+            });
+            context.addChatRun(clientRunId, {
+                sessionKey: p.sessionKey,
+                clientRunId,
+            });
+            if (store) {
+                store[p.sessionKey] = sessionEntry;
+                if (storePath) {
+                    await saveSessionStore(storePath, store);
+                }
+            }
+            await agentCommand({
+                message: messageWithAttachments,
+                sessionId,
+                runId: clientRunId,
+                thinking: p.thinking,
+                deliver: p.deliver,
+                timeout: Math.ceil(timeoutMs / 1000).toString(),
+                messageProvider: "webchat",
+                abortSignal: abortController.signal,
+            }, defaultRuntime, context.deps);
+            const payload = {
+                runId: clientRunId,
+                status: "ok",
+            };
+            context.dedupe.set(`chat:${clientRunId}`, {
+                ts: Date.now(),
+                ok: true,
+                payload,
+            });
+            respond(true, payload, undefined, { runId: clientRunId });
+        }
+        catch (err) {
+            const error = errorShape(ErrorCodes.UNAVAILABLE, String(err));
+            const payload = {
+                runId: clientRunId,
+                status: "error",
+                summary: String(err),
+            };
+            context.dedupe.set(`chat:${clientRunId}`, {
+                ts: Date.now(),
+                ok: false,
+                payload,
+                error,
+            });
+            respond(false, payload, error, {
+                runId: clientRunId,
+                error: formatForLog(err),
+            });
+        }
+        finally {
+            context.chatAbortControllers.delete(clientRunId);
+        }
+    },
+};

package/dist/gateway/server-methods/config.js

@@ -0,0 +1,50 @@
+import { CONFIG_PATH_NEXUS, parseConfigJson5, readConfigFileSnapshot, validateConfigObject, writeConfigFile, } from "../../config/config.js";
+import { buildConfigSchema } from "../../config/schema.js";
+import { ErrorCodes, errorShape, formatValidationErrors, validateConfigGetParams, validateConfigSchemaParams, validateConfigSetParams, } from "../protocol/index.js";
+export const configHandlers = {
+    "config.get": async ({ params, respond }) => {
+        if (!validateConfigGetParams(params)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid config.get params: ${formatValidationErrors(validateConfigGetParams.errors)}`));
+            return;
+        }
+        const snapshot = await readConfigFileSnapshot();
+        respond(true, snapshot, undefined);
+    },
+    "config.schema": ({ params, respond }) => {
+        if (!validateConfigSchemaParams(params)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid config.schema params: ${formatValidationErrors(validateConfigSchemaParams.errors)}`));
+            return;
+        }
+        const schema = buildConfigSchema();
+        respond(true, schema, undefined);
+    },
+    "config.set": async ({ params, respond }) => {
+        if (!validateConfigSetParams(params)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid config.set params: ${formatValidationErrors(validateConfigSetParams.errors)}`));
+            return;
+        }
+        const rawValue = params.raw;
+        if (typeof rawValue !== "string") {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, "invalid config.set params: raw (string) required"));
+            return;
+        }
+        const parsedRes = parseConfigJson5(rawValue);
+        if (!parsedRes.ok) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, parsedRes.error));
+            return;
+        }
+        const validated = validateConfigObject(parsedRes.parsed);
+        if (!validated.ok) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, "invalid config", {
+                details: { issues: validated.issues },
+            }));
+            return;
+        }
+        await writeConfigFile(validated.config);
+        respond(true, {
+            ok: true,
+            path: CONFIG_PATH_NEXUS,
+            config: validated.config,
+        }, undefined);
+    },
+};

package/dist/gateway/server-methods/connect.js

@@ -0,0 +1,6 @@
+import { ErrorCodes, errorShape } from "../protocol/index.js";
+export const connectHandlers = {
+    connect: ({ respond }) => {
+        respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, "connect is only valid as the first request"));
+    },
+};

package/dist/gateway/server-methods/cron.js

@@ -0,0 +1,89 @@
+import { normalizeCronJobCreate, normalizeCronJobPatch, } from "../../cron/normalize.js";
+import { readCronRunLogEntries, resolveCronRunLogPath, } from "../../cron/run-log.js";
+import { ErrorCodes, errorShape, formatValidationErrors, validateCronAddParams, validateCronListParams, validateCronRemoveParams, validateCronRunParams, validateCronRunsParams, validateCronStatusParams, validateCronUpdateParams, validateWakeParams, } from "../protocol/index.js";
+export const cronHandlers = {
+    wake: ({ params, respond, context }) => {
+        if (!validateWakeParams(params)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid wake params: ${formatValidationErrors(validateWakeParams.errors)}`));
+            return;
+        }
+        const p = params;
+        const result = context.cron.wake({ mode: p.mode, text: p.text });
+        respond(true, result, undefined);
+    },
+    "cron.list": async ({ params, respond, context }) => {
+        if (!validateCronListParams(params)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid cron.list params: ${formatValidationErrors(validateCronListParams.errors)}`));
+            return;
+        }
+        const p = params;
+        const jobs = await context.cron.list({
+            includeDisabled: p.includeDisabled,
+        });
+        respond(true, { jobs }, undefined);
+    },
+    "cron.status": async ({ params, respond, context }) => {
+        if (!validateCronStatusParams(params)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid cron.status params: ${formatValidationErrors(validateCronStatusParams.errors)}`));
+            return;
+        }
+        const status = await context.cron.status();
+        respond(true, status, undefined);
+    },
+    "cron.add": async ({ params, respond, context }) => {
+        const normalized = normalizeCronJobCreate(params) ?? params;
+        if (!validateCronAddParams(normalized)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid cron.add params: ${formatValidationErrors(validateCronAddParams.errors)}`));
+            return;
+        }
+        const job = await context.cron.add(normalized);
+        respond(true, job, undefined);
+    },
+    "cron.update": async ({ params, respond, context }) => {
+        const normalizedPatch = normalizeCronJobPatch(params?.patch);
+        const candidate = normalizedPatch && typeof params === "object" && params !== null
+            ? { ...params, patch: normalizedPatch }
+            : params;
+        if (!validateCronUpdateParams(candidate)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid cron.update params: ${formatValidationErrors(validateCronUpdateParams.errors)}`));
+            return;
+        }
+        const p = candidate;
+        const job = await context.cron.update(p.id, p.patch);
+        respond(true, job, undefined);
+    },
+    "cron.remove": async ({ params, respond, context }) => {
+        if (!validateCronRemoveParams(params)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid cron.remove params: ${formatValidationErrors(validateCronRemoveParams.errors)}`));
+            return;
+        }
+        const p = params;
+        const result = await context.cron.remove(p.id);
+        respond(true, result, undefined);
+    },
+    "cron.run": async ({ params, respond, context }) => {
+        if (!validateCronRunParams(params)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid cron.run params: ${formatValidationErrors(validateCronRunParams.errors)}`));
+            return;
+        }
+        const p = params;
+        const result = await context.cron.run(p.id, p.mode);
+        respond(true, result, undefined);
+    },
+    "cron.runs": async ({ params, respond, context }) => {
+        if (!validateCronRunsParams(params)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid cron.runs params: ${formatValidationErrors(validateCronRunsParams.errors)}`));
+            return;
+        }
+        const p = params;
+        const logPath = resolveCronRunLogPath({
+            storePath: context.cronStorePath,
+            jobId: p.id,
+        });
+        const entries = await readCronRunLogEntries(logPath, {
+            limit: p.limit,
+            jobId: p.id,
+        });
+        respond(true, { entries }, undefined);
+    },
+};

package/dist/gateway/server-methods/health.js

@@ -0,0 +1,28 @@
+import { getStatusSummary } from "../../commands/status.js";
+import { ErrorCodes, errorShape } from "../protocol/index.js";
+import { HEALTH_REFRESH_INTERVAL_MS } from "../server-constants.js";
+import { formatError } from "../server-utils.js";
+import { formatForLog } from "../ws-log.js";
+export const healthHandlers = {
+    health: async ({ respond, context }) => {
+        const { getHealthCache, refreshHealthSnapshot, logHealth } = context;
+        const now = Date.now();
+        const cached = getHealthCache();
+        if (cached && now - cached.ts < HEALTH_REFRESH_INTERVAL_MS) {
+            respond(true, cached, undefined, { cached: true });
+            void refreshHealthSnapshot({ probe: false }).catch((err) => logHealth.error(`background health refresh failed: ${formatError(err)}`));
+            return;
+        }
+        try {
+            const snap = await refreshHealthSnapshot({ probe: false });
+            respond(true, snap, undefined);
+        }
+        catch (err) {
+            respond(false, undefined, errorShape(ErrorCodes.UNAVAILABLE, formatForLog(err)));
+        }
+    },
+    status: async ({ respond }) => {
+        const status = await getStatusSummary();
+        respond(true, status, undefined);
+    },
+};

package/dist/gateway/server-methods/models.js

@@ -0,0 +1,16 @@
+import { ErrorCodes, errorShape, formatValidationErrors, validateModelsListParams, } from "../protocol/index.js";
+export const modelsHandlers = {
+    "models.list": async ({ params, respond, context }) => {
+        if (!validateModelsListParams(params)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid models.list params: ${formatValidationErrors(validateModelsListParams.errors)}`));
+            return;
+        }
+        try {
+            const models = await context.loadGatewayModelCatalog();
+            respond(true, { models }, undefined);
+        }
+        catch (err) {
+            respond(false, undefined, errorShape(ErrorCodes.UNAVAILABLE, String(err)));
+        }
+    },
+};