clawdbot 2026.1.4-1

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

@@ -0,0 +1,250 @@
+import { randomUUID } from "node:crypto";
+import { agentCommand } from "../../commands/agent.js";
+import { loadConfig } from "../../config/config.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 { normalizeE164 } from "../../utils.js";
+import { ErrorCodes, errorShape, formatValidationErrors, validateAgentParams, validateAgentWaitParams, } from "../protocol/index.js";
+import { loadSessionEntry } from "../session-utils.js";
+import { formatForLog } from "../ws-log.js";
+import { waitForAgentJob } from "./agent-job.js";
+export const agentHandlers = {
+    agent: async ({ params, respond, context }) => {
+        const p = params;
+        if (!validateAgentParams(p)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid agent params: ${formatValidationErrors(validateAgentParams.errors)}`));
+            return;
+        }
+        const request = p;
+        const idem = request.idempotencyKey;
+        const cached = context.dedupe.get(`agent:${idem}`);
+        if (cached) {
+            respond(cached.ok, cached.payload, cached.error, {
+                cached: true,
+            });
+            return;
+        }
+        const message = request.message.trim();
+        const requestedSessionKey = typeof request.sessionKey === "string" && request.sessionKey.trim()
+            ? request.sessionKey.trim()
+            : undefined;
+        let resolvedSessionId = request.sessionId?.trim() || undefined;
+        let sessionEntry;
+        let bestEffortDeliver = false;
+        let cfgForAgent;
+        if (requestedSessionKey) {
+            const { cfg, storePath, store, entry } = loadSessionEntry(requestedSessionKey);
+            cfgForAgent = cfg;
+            const now = Date.now();
+            const sessionId = entry?.sessionId ?? randomUUID();
+            sessionEntry = {
+                sessionId,
+                updatedAt: now,
+                thinkingLevel: entry?.thinkingLevel,
+                verboseLevel: entry?.verboseLevel,
+                systemSent: entry?.systemSent,
+                sendPolicy: entry?.sendPolicy,
+                skillsSnapshot: entry?.skillsSnapshot,
+                lastChannel: entry?.lastChannel,
+                lastTo: entry?.lastTo,
+            };
+            const sendPolicy = resolveSendPolicy({
+                cfg,
+                entry,
+                sessionKey: requestedSessionKey,
+                surface: entry?.surface,
+                chatType: entry?.chatType,
+            });
+            if (sendPolicy === "deny") {
+                respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, "send blocked by session policy"));
+                return;
+            }
+            if (store) {
+                store[requestedSessionKey] = sessionEntry;
+                if (storePath) {
+                    await saveSessionStore(storePath, store);
+                }
+            }
+            resolvedSessionId = sessionId;
+            const mainKey = (cfg.session?.mainKey ?? "main").trim() || "main";
+            if (requestedSessionKey === mainKey) {
+                context.addChatRun(idem, {
+                    sessionKey: requestedSessionKey,
+                    clientRunId: idem,
+                });
+                bestEffortDeliver = true;
+            }
+            registerAgentRunContext(idem, { sessionKey: requestedSessionKey });
+        }
+        const runId = idem;
+        const requestedChannelRaw = typeof request.channel === "string" ? request.channel.trim() : "";
+        const requestedChannelNormalized = requestedChannelRaw
+            ? requestedChannelRaw.toLowerCase()
+            : "last";
+        const requestedChannel = requestedChannelNormalized === "imsg"
+            ? "imessage"
+            : requestedChannelNormalized;
+        const lastChannel = sessionEntry?.lastChannel;
+        const lastTo = typeof sessionEntry?.lastTo === "string"
+            ? sessionEntry.lastTo.trim()
+            : "";
+        const resolvedChannel = (() => {
+            if (requestedChannel === "last") {
+                // WebChat is not a deliverable surface. Treat it as "unset" for routing,
+                // so VoiceWake and CLI callers don't get stuck with deliver=false.
+                return lastChannel && lastChannel !== "webchat"
+                    ? lastChannel
+                    : "whatsapp";
+            }
+            if (requestedChannel === "whatsapp" ||
+                requestedChannel === "telegram" ||
+                requestedChannel === "discord" ||
+                requestedChannel === "signal" ||
+                requestedChannel === "imessage" ||
+                requestedChannel === "webchat") {
+                return requestedChannel;
+            }
+            return lastChannel && lastChannel !== "webchat"
+                ? lastChannel
+                : "whatsapp";
+        })();
+        const resolvedTo = (() => {
+            const explicit = typeof request.to === "string" && request.to.trim()
+                ? request.to.trim()
+                : undefined;
+            if (explicit)
+                return explicit;
+            if (resolvedChannel === "whatsapp" ||
+                resolvedChannel === "telegram" ||
+                resolvedChannel === "discord" ||
+                resolvedChannel === "signal" ||
+                resolvedChannel === "imessage") {
+                return lastTo || undefined;
+            }
+            return undefined;
+        })();
+        const sanitizedTo = (() => {
+            // If we derived a WhatsApp recipient from session "lastTo", ensure it is still valid
+            // for the configured allowlist. Otherwise, fall back to the first allowed number so
+            // voice wake doesn't silently route to stale/test recipients.
+            if (resolvedChannel !== "whatsapp")
+                return resolvedTo;
+            const explicit = typeof request.to === "string" && request.to.trim()
+                ? request.to.trim()
+                : undefined;
+            if (explicit)
+                return resolvedTo;
+            const cfg = cfgForAgent ?? loadConfig();
+            const rawAllow = cfg.whatsapp?.allowFrom ?? [];
+            if (rawAllow.includes("*"))
+                return resolvedTo;
+            const allowFrom = rawAllow
+                .map((val) => normalizeE164(val))
+                .filter((val) => val.length > 1);
+            if (allowFrom.length === 0)
+                return resolvedTo;
+            const normalizedLast = typeof resolvedTo === "string" && resolvedTo.trim()
+                ? normalizeE164(resolvedTo)
+                : undefined;
+            if (normalizedLast && allowFrom.includes(normalizedLast)) {
+                return normalizedLast;
+            }
+            return allowFrom[0];
+        })();
+        const deliver = request.deliver === true && resolvedChannel !== "webchat";
+        const accepted = {
+            runId,
+            status: "accepted",
+            acceptedAt: Date.now(),
+        };
+        // Store an in-flight ack so retries do not spawn a second run.
+        context.dedupe.set(`agent:${idem}`, {
+            ts: Date.now(),
+            ok: true,
+            payload: accepted,
+        });
+        respond(true, accepted, undefined, { runId });
+        void agentCommand({
+            message,
+            to: sanitizedTo,
+            sessionId: resolvedSessionId,
+            thinking: request.thinking,
+            deliver,
+            provider: resolvedChannel,
+            timeout: request.timeout?.toString(),
+            bestEffortDeliver,
+            surface: "VoiceWake",
+            runId,
+            lane: request.lane,
+            extraSystemPrompt: request.extraSystemPrompt,
+        }, defaultRuntime, context.deps)
+            .then(() => {
+            const payload = {
+                runId,
+                status: "ok",
+                summary: "completed",
+            };
+            context.dedupe.set(`agent:${idem}`, {
+                ts: Date.now(),
+                ok: true,
+                payload,
+            });
+            // Send a second res frame (same id) so TS clients with expectFinal can wait.
+            // Swift clients will typically treat the first res as the result and ignore this.
+            respond(true, payload, undefined, { runId });
+        })
+            .catch((err) => {
+            const error = errorShape(ErrorCodes.UNAVAILABLE, String(err));
+            const payload = {
+                runId,
+                status: "error",
+                summary: String(err),
+            };
+            context.dedupe.set(`agent:${idem}`, {
+                ts: Date.now(),
+                ok: false,
+                payload,
+                error,
+            });
+            respond(false, payload, error, {
+                runId,
+                error: formatForLog(err),
+            });
+        });
+    },
+    "agent.wait": async ({ params, respond }) => {
+        if (!validateAgentWaitParams(params)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid agent.wait params: ${formatValidationErrors(validateAgentWaitParams.errors)}`));
+            return;
+        }
+        const p = params;
+        const runId = p.runId.trim();
+        const afterMs = typeof p.afterMs === "number" && Number.isFinite(p.afterMs)
+            ? Math.max(0, Math.floor(p.afterMs))
+            : undefined;
+        const timeoutMs = typeof p.timeoutMs === "number" && Number.isFinite(p.timeoutMs)
+            ? Math.max(0, Math.floor(p.timeoutMs))
+            : 30_000;
+        const snapshot = await waitForAgentJob({
+            runId,
+            afterMs,
+            timeoutMs,
+        });
+        if (!snapshot) {
+            respond(true, {
+                runId,
+                status: "timeout",
+            });
+            return;
+        }
+        respond(true, {
+            runId,
+            status: snapshot.state === "done" ? "ok" : "error",
+            startedAt: snapshot.startedAt,
+            endedAt: snapshot.endedAt,
+            error: snapshot.error,
+        });
+    },
+};

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

@@ -0,0 +1,200 @@
+import { randomUUID } from "node:crypto";
+import { resolveThinkingDefault } from "../../agents/model-selection.js";
+import { agentCommand } from "../../commands/agent.js";
+import { saveSessionStore } from "../../config/sessions.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(active.sessionId, runId, sessionKey);
+        const payload = {
+            runId,
+            sessionKey,
+            seq: (context.agentRunSeq.get(active.sessionId) ?? 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, client: _client, isWebchatConnect: _isWebchatConnect, }) => {
+        if (!validateChatSendParams(params)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid chat.send params: ${formatValidationErrors(validateChatSendParams.errors)}`));
+            return;
+        }
+        const p = params;
+        const timeoutMs = Math.min(Math.max(p.timeoutMs ?? 30_000, 0), 30_000);
+        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 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,
+            lastChannel: entry?.lastChannel,
+            lastTo: entry?.lastTo,
+        };
+        const clientRunId = p.idempotencyKey;
+        const sendPolicy = resolveSendPolicy({
+            cfg,
+            entry,
+            sessionKey: p.sessionKey,
+            surface: entry?.surface,
+            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(sessionId, {
+                sessionKey: p.sessionKey,
+                clientRunId,
+            });
+            if (store) {
+                store[p.sessionKey] = sessionEntry;
+                if (storePath) {
+                    await saveSessionStore(storePath, store);
+                }
+            }
+            await agentCommand({
+                message: messageWithAttachments,
+                sessionId,
+                thinking: p.thinking,
+                deliver: p.deliver,
+                timeout: Math.ceil(timeoutMs / 1000).toString(),
+                surface: "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_CLAWDBOT, 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_CLAWDBOT,
+            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,83 @@
+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 }) => {
+        if (!validateCronAddParams(params)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid cron.add params: ${formatValidationErrors(validateCronAddParams.errors)}`));
+            return;
+        }
+        const job = await context.cron.add(params);
+        respond(true, job, undefined);
+    },
+    "cron.update": async ({ params, respond, context }) => {
+        if (!validateCronUpdateParams(params)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid cron.update params: ${formatValidationErrors(validateCronUpdateParams.errors)}`));
+            return;
+        }
+        const p = params;
+        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)));
+        }
+    },
+};