@jack200714/mafw 4.5.1

package/gateway/dist/routes/model-config.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleModelConfigGet = handleModelConfigGet;
+exports.handleModelConfigUpdate = handleModelConfigUpdate;
+const logger_1 = require("../core/utils/logger");
+function readBody(req) {
+    return new Promise((resolve, reject) => {
+        let body = '';
+        req.on('data', (chunk) => body += chunk);
+        req.on('end', () => resolve(body));
+        req.on('error', reject);
+    });
+}
+const MEDIA_MODALITIES = ['image', 'video', 'audio'];
+function json(res, status, payload) {
+    res.writeHead(status, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify(payload));
+}
+/** Empty-string provider+model = "follow default" clear path — skips strict validation. */
+function isClearRef(ref) {
+    return (ref?.provider ?? '') === '' && (ref?.model ?? '') === '';
+}
+function findProvider(list, providerID) {
+    return list.find(p => p.providerID === providerID);
+}
+function validateRecall(ref, available) {
+    const prov = findProvider(available, ref?.providerID ?? '');
+    if (!prov)
+        return `Provider '${ref?.providerID ?? ''}' not found`;
+    if (!prov.models.some(m => m.id === ref.modelID)) {
+        return `Model '${ref.modelID}' not found under provider '${ref.providerID}'`;
+    }
+    return null;
+}
+/** Validate a media ref; empty provider falls back to the current top-level provider. */
+function validateMediaRef(ref, fallbackProvider, available) {
+    const effProvider = ref?.provider || fallbackProvider || '';
+    const prov = findProvider(available, effProvider);
+    if (!prov)
+        return `Provider '${effProvider}' not found`;
+    if (ref?.model && !prov.models.some(m => m.id === ref.model)) {
+        return `Model '${ref.model}' not found under provider '${effProvider}'`;
+    }
+    return null;
+}
+async function handleModelConfigGet(req, res, deps) {
+    try {
+        const available = await deps.listProviders().catch(() => null);
+        const cur = deps.currentConfig();
+        json(res, 200, { recall: cur.recall, media: cur.media, available });
+    }
+    catch (err) {
+        json(res, 500, { error: err.message });
+    }
+}
+async function handleModelConfigUpdate(req, res, deps) {
+    let body;
+    try {
+        body = JSON.parse(await readBody(req));
+    }
+    catch (err) {
+        json(res, 400, { error: err.message });
+        return;
+    }
+    const recallUpdate = body?.recall ?? null;
+    const mediaUpdate = {};
+    for (const key of ['provider', 'model', ...MEDIA_MODALITIES]) {
+        if (body?.media?.[key] !== undefined)
+            mediaUpdate[key] = body.media[key];
+    }
+    if (!recallUpdate && Object.keys(mediaUpdate).length === 0) {
+        json(res, 400, { error: 'No model config specified' });
+        return;
+    }
+    // recall must always be a complete pair (no clear concept for the worker model).
+    if (recallUpdate && (!recallUpdate.providerID || !recallUpdate.modelID)) {
+        json(res, 400, { error: 'recall.workerModel requires both providerID and modelID' });
+        return;
+    }
+    const available = await deps.listProviders().catch(() => null);
+    if (available !== null) {
+        if (recallUpdate) {
+            const err = validateRecall(recallUpdate, available);
+            if (err) {
+                json(res, 400, { error: err, available });
+                return;
+            }
+        }
+        // Top-level media pair: both empty = reset to built-in default (skip);
+        // partial pair falls back to the current persisted provider for validation.
+        const pairProvider = mediaUpdate.provider ?? '';
+        const pairModel = mediaUpdate.model ?? '';
+        if (pairProvider !== '' || pairModel !== '') {
+            const pairErr = validateMediaRef({ provider: pairProvider, model: pairModel }, deps.currentConfig().media.provider, available);
+            if (pairErr) {
+                json(res, 400, { error: pairErr, available });
+                return;
+            }
+        }
+        for (const modality of MEDIA_MODALITIES) {
+            const ref = mediaUpdate[modality];
+            if (ref && !isClearRef(ref)) {
+                const err = validateMediaRef(ref, mediaUpdate.provider ?? deps.currentConfig().media.provider, available);
+                if (err) {
+                    json(res, 400, { error: err, available });
+                    return;
+                }
+            }
+        }
+    }
+    try {
+        const overrides = {};
+        if (recallUpdate)
+            overrides.recall = { workerModel: { providerID: recallUpdate.providerID, modelID: recallUpdate.modelID } };
+        if (Object.keys(mediaUpdate).length > 0)
+            overrides.media = mediaUpdate;
+        deps.persist(overrides);
+        if (recallUpdate) {
+            try {
+                deps.invalidateScanService();
+            }
+            catch (err) {
+                logger_1.log.warn(`[ModelConfig] invalidateScanService failed: ${err.message}`);
+            }
+        }
+        const cur = deps.currentConfig();
+        json(res, 200, { success: true, recall: cur.recall, media: cur.media });
+    }
+    catch (err) {
+        json(res, 500, { error: err.message });
+    }
+}

package/gateway/dist/routes/note-board.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NOTE_BOARD_BUDGET = void 0;
+exports.handleNoteBoard = handleNoteBoard;
+var inject_format_1 = require("../recall/inject-format");
+Object.defineProperty(exports, "NOTE_BOARD_BUDGET", { enumerable: true, get: function () { return inject_format_1.NOTE_BOARD_BUDGET; } });
+/**
+ * Scan the harmonic index for sticky (not expired, not superseded) entries,
+ * sort soonest-expiry first, load full memory values, and render the note
+ * board. Malformed sticky_until fails open (stays on board, sorted last) —
+ * mirroring mem0's expiration semantics. Board membership expires, the
+ * memory itself never does. `now` is injectable for tests.
+ */
+async function handleNoteBoard(deps, now = new Date()) {
+    const { formatNoteBoard, NOTE_BOARD_BUDGET } = require('../recall/inject-format');
+    const active = [];
+    for (const e of deps.getIndex().entries) {
+        if (!e.sticky_until || e.superseded_by)
+            continue;
+        const ms = new Date(e.sticky_until).getTime();
+        if (Number.isNaN(ms)) {
+            active.push({ entry: e, untilMs: Number.POSITIVE_INFINITY }); // fail-open, sort last
+        }
+        else if (ms > now.getTime()) {
+            active.push({ entry: e, untilMs: ms });
+        }
+    }
+    active.sort((a, b) => a.untilMs - b.untilMs);
+    const units = [];
+    for (const { entry } of active) {
+        const u = await deps.readUnit(entry.id);
+        // The index entry is authoritative for board membership; fall back to its
+        // sticky_until when the OKF frontmatter predates the field.
+        if (u)
+            units.push(u.sticky_until ? u : { ...u, sticky_until: entry.sticky_until });
+    }
+    const { board, used } = formatNoteBoard(units, now);
+    if (units.length > used) {
+        console.log(`[Recall] note-board overflow: ${units.length - used} entries dropped`);
+    }
+    const entries = units.slice(0, used).map(u => ({
+        id: u.id,
+        type: u.type,
+        primary_abstraction: u.primary_abstraction,
+        memory_value: u.memory_value,
+        energy: u.energy,
+        created_at: u.created_at,
+        sticky_until: u.sticky_until,
+    }));
+    return { board, entries, budget: { ...NOTE_BOARD_BUDGET, used } };
+}

package/gateway/dist/routes/permission.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handlePermissionReply = handlePermissionReply;
+function readBody(req) {
+    return new Promise((resolve, reject) => {
+        let body = '';
+        req.on('data', (chunk) => body += chunk);
+        req.on('end', () => resolve(body));
+        req.on('error', reject);
+    });
+}
+async function handlePermissionReply(runtime, req, res, sessionID, requestId) {
+    if (!runtime?.session?.permissionReply) {
+        res.writeHead(503, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'Runtime does not support permissionReply' }));
+        return;
+    }
+    try {
+        const body = JSON.parse(await readBody(req) || '{}');
+        let reply = body.reply;
+        let message = body.message;
+        if (typeof body.approved === 'boolean' && !reply) {
+            reply = body.approved ? 'once' : 'reject'; // legacy bool callers
+        }
+        if (reply !== 'once' && reply !== 'always' && reply !== 'reject') {
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: "reply must be 'once'|'always'|'reject'" }));
+            return;
+        }
+        const result = await runtime.session.permissionReply(sessionID, requestId, reply, message);
+        if (!result) {
+            res.writeHead(404, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'Permission request not found' }));
+            return;
+        }
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ success: true }));
+    }
+    catch (err) {
+        res.writeHead(500, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: err.message }));
+    }
+}

package/gateway/dist/routes/pinned-recall.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PINNED_BUDGET = void 0;
+exports.handleRecallPinned = handleRecallPinned;
+var inject_format_1 = require("../recall/inject-format");
+Object.defineProperty(exports, "PINNED_BUDGET", { enumerable: true, get: function () { return inject_format_1.PINNED_BUDGET; } });
+/**
+ * Scan the harmonic index for pinned (and not superseded) entries, sort by
+ * energy × salience, load full memory values, and render the disclosure
+ * profile. Overflow beyond the budget is logged here (formatter only counts).
+ */
+async function handleRecallPinned(deps) {
+    const { formatPinnedProfile, PINNED_BUDGET } = require('../recall/inject-format');
+    const pinned = deps.getIndex().entries.filter((e) => e.pinned && !e.superseded_by);
+    pinned.sort((a, b) => (b.energy ?? 0) * (b.salience ?? 1) - (a.energy ?? 0) * (a.salience ?? 1));
+    const units = [];
+    for (const e of pinned) {
+        const u = await deps.readUnit(e.id);
+        if (u)
+            units.push(u);
+    }
+    const { profile, used } = formatPinnedProfile(units);
+    if (units.length > used) {
+        console.log(`[Recall] pinned overflow: ${units.length - used} entries dropped`);
+    }
+    const entries = units.slice(0, used).map(u => ({
+        id: u.id,
+        type: u.type,
+        primary_abstraction: u.primary_abstraction,
+        memory_value: u.memory_value,
+        energy: u.energy,
+        salience: u.salience,
+        created_at: u.created_at,
+    }));
+    return { profile, entries, budget: { max: PINNED_BUDGET.max, maxChars: PINNED_BUDGET.maxChars, used } };
+}

package/gateway/dist/routes/plugins.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handlePluginsList = handlePluginsList;
+exports.handlePluginsInstall = handlePluginsInstall;
+exports.handlePluginsEnable = handlePluginsEnable;
+exports.handlePluginsDisable = handlePluginsDisable;
+exports.handlePluginsDelete = handlePluginsDelete;
+const logger_1 = require("../core/utils/logger");
+const hub_1 = require("../plugins/hub");
+function readBody(req) {
+    return new Promise((resolve, reject) => {
+        let body = '';
+        req.on('data', (c) => body += c);
+        req.on('end', () => resolve(body));
+        req.on('error', reject);
+    });
+}
+async function readJsonBody(req) {
+    const raw = await readBody(req);
+    try {
+        return JSON.parse(raw);
+    }
+    catch (err) {
+        throw new hub_1.HubError(400, `invalid JSON body: ${err.message}`);
+    }
+}
+function send(res, status, payload) {
+    res.writeHead(status, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify(payload));
+}
+async function guarded(res, fn) {
+    try {
+        const result = await fn();
+        send(res, 200, result);
+    }
+    catch (err) {
+        if (err instanceof hub_1.HubError) {
+            send(res, err.status, { error: err.message });
+            return;
+        }
+        logger_1.log.error(`[PluginsHub] unexpected error: ${err.message}`);
+        send(res, 500, { error: err.message });
+    }
+}
+async function handlePluginsList(_req, res, deps) {
+    await guarded(res, async () => ({ plugins: (0, hub_1.listPlugins)(deps.hub) }));
+}
+async function handlePluginsInstall(req, res, deps) {
+    await guarded(res, async () => {
+        const body = await readJsonBody(req);
+        const entry = await (0, hub_1.installPlugin)(deps.hub, {
+            type: body.type, filename: body.filename, contentBase64: body.contentBase64, overwrite: !!body.overwrite,
+        });
+        logger_1.log.info(`[PluginsHub] installed ${body.type}/${body.filename}`);
+        return entry;
+    });
+}
+async function handlePluginsEnable(req, res, deps) {
+    await guarded(res, async () => {
+        const body = await readJsonBody(req);
+        return (0, hub_1.setPluginEnabled)(deps.hub, { type: body.type, filename: body.filename, enabled: true });
+    });
+}
+async function handlePluginsDisable(req, res, deps) {
+    await guarded(res, async () => {
+        const body = await readJsonBody(req);
+        return (0, hub_1.setPluginEnabled)(deps.hub, { type: body.type, filename: body.filename, enabled: false });
+    });
+}
+async function handlePluginsDelete(req, res, deps) {
+    await guarded(res, async () => {
+        const body = await readJsonBody(req);
+        const out = await (0, hub_1.deletePlugin)(deps.hub, { type: body.type, filename: body.filename });
+        logger_1.log.info(`[PluginsHub] deleted ${body.type}/${body.filename}`);
+        return out;
+    });
+}

package/gateway/dist/routes/restart-agent.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleRestartAgent = handleRestartAgent;
+async function handleRestartAgent(req, res, deps) {
+    const json = (status, body) => {
+        res.writeHead(status, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify(body));
+    };
+    if (deps.capabilities().agentProcessApi !== true) {
+        json(503, { error: 'runtime does not own the agent process (external or in-process runtime)' });
+        return;
+    }
+    if (deps.isRecovering() || deps.isSwitching()) {
+        json(409, { error: 'agent process recovery/runtime switch already in progress' });
+        return;
+    }
+    deps.begin();
+    try {
+        const { mode } = await deps.restartAgent();
+        json(200, { success: true, mode });
+    }
+    catch (err) {
+        json(500, { error: err.message });
+    }
+    finally {
+        deps.end();
+    }
+}

package/gateway/dist/routes/runtime-switch.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleRuntimeGet = handleRuntimeGet;
+exports.handleRuntimeSwitch = handleRuntimeSwitch;
+exports.handleRuntimeReload = handleRuntimeReload;
+const logger_1 = require("../core/utils/logger");
+function readBody(req) {
+    return new Promise((resolve, reject) => {
+        let body = '';
+        req.on('data', (chunk) => body += chunk);
+        req.on('end', () => resolve(body));
+        req.on('error', reject);
+    });
+}
+// ─── GET /api/runtime ─── active runtime identity + capabilities + plugin scan state
+async function handleRuntimeGet(_req, res, deps) {
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({
+        active: {
+            name: deps.runtimeName(),
+            capabilities: deps.runtimeCaps(),
+            envOverride: deps.envOverride(),
+        },
+        plugins: deps.loader?.getState() ?? [],
+    }));
+}
+// ─── POST /api/runtime/switch ─── hot-swap the active runtime plugin
+async function handleRuntimeSwitch(req, res, deps) {
+    let body;
+    try {
+        body = JSON.parse(await readBody(req));
+    }
+    catch (err) {
+        res.writeHead(400, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: err.message }));
+        return;
+    }
+    const plugin = typeof body?.plugin === 'string' ? body.plugin.trim() : '';
+    if (plugin && plugin !== 'opencode') {
+        const found = deps.loader?.get(plugin);
+        if (!found) {
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({
+                error: `Runtime plugin '${plugin}' not found`,
+                available: deps.loader?.getState().map(s => s.name).filter(Boolean) ?? [],
+            }));
+            return;
+        }
+    }
+    try {
+        deps.persist({ runtime: { plugin } });
+        const prev = deps.getCurrent();
+        const rt = await deps.createRuntime();
+        await deps.onSwitched(rt, prev);
+        logger_1.log.info(`[Runtime] switched to '${rt.name}' (capabilities: ${JSON.stringify(rt.capabilities)})`);
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({
+            success: true,
+            active: { name: rt.name, capabilities: rt.capabilities },
+            envOverride: deps.envOverride(),
+        }));
+    }
+    catch (err) {
+        res.writeHead(500, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: err.message }));
+    }
+}
+// ─── POST /api/runtime/reload ─── rescan plugins without switching
+async function handleRuntimeReload(_req, res, deps) {
+    if (!deps.loader) {
+        res.writeHead(503, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'Runtime plugin loader not available' }));
+        return;
+    }
+    await deps.loader.scan();
+    const state = deps.loader.getState();
+    logger_1.log.info(`[Runtime] reloaded plugins (${state.length} scanned)`);
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ plugins: state }));
+}

package/gateway/dist/routes/session-branch.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleSessionBranch = handleSessionBranch;
+function readBody(req) {
+    return new Promise((resolve) => {
+        let body = '';
+        req.on('data', (c) => (body += c));
+        req.on('end', () => { try {
+            resolve(body ? JSON.parse(body) : {});
+        }
+        catch {
+            resolve({});
+        } });
+        req.on('error', () => resolve({}));
+    });
+}
+function json(res, status, payload) {
+    res.writeHead(status, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify(payload));
+}
+/**
+ * 分支原语薄代理（spec 2026-09-14 §1）。能力门：runtime 未声明
+ * sessionBranchApi → 503；unrevert 是 opencode-only（pi 方法缺席）→ 404。
+ * 返回 handled=false 表示路径不匹配，交给后续路由。
+ */
+async function handleSessionBranch(req, res, url, deps) {
+    const m = url.match(/^\/api\/sessions\/([^/]+)\/(fork|revert|unrevert)(?:\?|$)/);
+    if (!m || req.method !== 'POST')
+        return false;
+    const [, sessionID, action] = m;
+    const rt = deps.getRuntime();
+    if (!rt?.capabilities?.sessionBranchApi) {
+        json(res, 503, { error: `capability 'sessionBranchApi' not available on runtime '${rt?.name ?? 'none'}'` });
+        return true;
+    }
+    const body = await readBody(req);
+    try {
+        if (action === 'fork') {
+            const session = await rt.session.fork({ sessionID, messageID: body?.messageID });
+            json(res, 200, { session });
+        }
+        else if (action === 'revert') {
+            if (typeof body?.messageID !== 'string' || !body.messageID) {
+                json(res, 400, { error: 'messageID required' });
+                return true;
+            }
+            await rt.session.revert({ sessionID, messageID: body.messageID, partID: body?.partID });
+            json(res, 200, {});
+        }
+        else {
+            if (typeof rt.session.unrevert !== 'function') {
+                json(res, 404, { error: `runtime '${rt.name}' does not implement unrevert` });
+                return true;
+            }
+            await rt.session.unrevert({ sessionID });
+            json(res, 200, {});
+        }
+    }
+    catch (err) {
+        json(res, 500, { error: err?.message ?? String(err) });
+    }
+    return true;
+}

package/gateway/dist/routes/session-mutations.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleSessionMutations = handleSessionMutations;
+/**
+ * DELETE /api/sessions/:id — true forward to serve's native session delete
+ * (the legacy /api/session/:id path is an SPA-fallback that answers 200 without
+ * deleting anything).
+ * PATCH /api/sessions/:id { title } — forward to serve's session update.
+ * Returns true when the request was handled (response already written).
+ */
+async function handleSessionMutations(req, res, deps) {
+    const deleteMatch = req.method === 'DELETE' ? req.url?.match(/^\/api\/sessions\/([^/?]+)(?:\?|$)/) : undefined;
+    const patchMatch = req.method === 'PATCH' ? req.url?.match(/^\/api\/sessions\/([^/?]+)(?:\?|$)/) : undefined;
+    if (!deleteMatch && !patchMatch)
+        return false;
+    const json = (status, body) => {
+        res.writeHead(status, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify(body));
+    };
+    const sessionID = (deleteMatch || patchMatch)[1];
+    if (deps.getCapabilities().sessionApi !== true) {
+        json(503, { error: 'runtime does not expose the session API (sessionApi=false)' });
+        return true;
+    }
+    const client = deps.getClient();
+    if (!client) {
+        json(503, { error: 'LLM client not available' });
+        return true;
+    }
+    try {
+        if (deleteMatch) {
+            await client.session.delete({ sessionID });
+            json(200, { ok: true });
+            return true;
+        }
+        const raw = await new Promise((resolve) => {
+            let chunks = '';
+            req.on('data', (c) => chunks += c);
+            req.on('error', () => resolve(''));
+            req.on('end', () => resolve(chunks));
+        });
+        let title = '';
+        try {
+            title = String(JSON.parse(raw || '{}').title ?? '');
+        }
+        catch { /* invalid json → empty */ }
+        if (!title.trim()) {
+            json(400, { error: 'title is required' });
+            return true;
+        }
+        await client.session.update({ sessionID, title: title.trim() });
+        json(200, { ok: true });
+    }
+    catch (err) {
+        json(500, { error: err.message });
+    }
+    return true;
+}

package/gateway/dist/routes/session-summarize.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleSessionSummarize = handleSessionSummarize;
+function readBody(req) {
+    return new Promise((resolve) => {
+        let body = '';
+        req.on('data', (c) => (body += c));
+        req.on('end', () => { try {
+            resolve(body ? JSON.parse(body) : {});
+        }
+        catch {
+            resolve({});
+        } });
+        req.on('error', () => resolve({}));
+    });
+}
+function json(res, status, payload) {
+    res.writeHead(status, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify(payload));
+}
+/**
+ * POST /api/session/:id/summarize — 手动压缩会话（TUI /compact）。
+ * 薄代理到 runtime.session.summarize（opencode 原生 compaction；pi 同步实现）。
+ * 返回 handled=false 表示路径不匹配，交给后续路由。
+ */
+async function handleSessionSummarize(req, res, url, deps) {
+    const m = url.match(/^\/api\/session\/([^/]+)\/summarize(?:\?|$)/);
+    if (!m || req.method !== 'POST')
+        return false;
+    const sessionID = m[1];
+    const rt = deps.getRuntime();
+    if (!rt?.session?.summarize) {
+        json(res, 503, { error: `runtime '${rt?.name ?? 'none'}' does not implement session.summarize` });
+        return true;
+    }
+    try {
+        const body = await readBody(req);
+        await rt.session.summarize({
+            sessionID,
+            ...(typeof body?.providerID === 'string' ? { providerID: body.providerID } : {}),
+            ...(typeof body?.modelID === 'string' ? { modelID: body.modelID } : {}),
+        });
+        json(res, 200, {});
+    }
+    catch (err) {
+        json(res, 500, { error: err?.message ?? String(err) });
+    }
+    return true;
+}