min-agent 0.4.1 → 0.5.0

package/dist/model-catalog.js

@@ -0,0 +1,285 @@
+import { readFileSync, mkdirSync, existsSync } from "fs";
+import path from "path";
+import { atomicWriteFileSync } from "./tools/atomic-file.js";
+import { getConfigDir, parseThinkingEffort } from "./config.js";
+const DEFAULT_LONAE_BASE = "https://models.lonae.com";
+const CACHE_TTL = 7 * 24 * 60 * 60 * 1000;
+const CATALOG_ENTRY_VERSION = 3;
+const NEGATIVE_TTL = 60 * 60 * 1000;
+const FETCH_TIMEOUT_MS = 10000;
+const memoryCache = new Map();
+const inFlight = new Map();
+const negativeCache = new Map();
+export function lonaeBaseUrl() {
+    const raw = process.env.MIN_AGENT_MODELS_API_URL?.trim();
+    if (!raw)
+        return DEFAULT_LONAE_BASE;
+    return raw.replace(/\/$/, "");
+}
+function cacheFile() {
+    return path.join(getConfigDir(), "model-catalog-cache.json");
+}
+function loadDiskCache() {
+    const file = cacheFile();
+    if (!existsSync(file))
+        return {};
+    try {
+        return JSON.parse(readFileSync(file, "utf-8"));
+    }
+    catch {
+        return {};
+    }
+}
+function saveDiskCache(cache) {
+    const file = cacheFile();
+    mkdirSync(path.dirname(file), { recursive: true });
+    atomicWriteFileSync(file, JSON.stringify(cache));
+}
+export function clearModelCatalogCache() {
+    memoryCache.clear();
+    inFlight.clear();
+    negativeCache.clear();
+}
+export function getCachedModelCatalog(modelId) {
+    const memory = memoryCache.get(modelId);
+    if (memory && memory.version === CATALOG_ENTRY_VERSION && Date.now() - memory.timestamp <= CACHE_TTL)
+        return memory;
+    const disk = loadDiskCache()[modelId];
+    if (!disk || disk.version !== CATALOG_ENTRY_VERSION || Date.now() - disk.timestamp > CACHE_TTL)
+        return null;
+    memoryCache.set(modelId, disk);
+    return disk;
+}
+function setCache(modelId, entry) {
+    memoryCache.set(modelId, entry);
+    const cache = loadDiskCache();
+    cache[modelId] = entry;
+    saveDiskCache(cache);
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+export function parseReasoningOptions(raw) {
+    if (!Array.isArray(raw))
+        return { toggle: false, efforts: [] };
+    let toggle = false;
+    const efforts = new Set();
+    for (const item of raw) {
+        if (!isRecord(item))
+            continue;
+        if (item.type === "toggle")
+            toggle = true;
+        if (item.type === "effort" && Array.isArray(item.values)) {
+            for (const value of item.values) {
+                if (typeof value === "string" && value && value !== "default")
+                    efforts.add(value);
+            }
+        }
+    }
+    if (efforts.has("none"))
+        toggle = true;
+    return { toggle, efforts: [...efforts] };
+}
+export function pickListedModel(models, modelId) {
+    const lower = modelId.toLowerCase();
+    const exact = models.find((m) => m.id.toLowerCase() === lower);
+    if (exact)
+        return exact;
+    const suffix = models.find((m) => {
+        const id = m.id.toLowerCase();
+        return id.endsWith(`/${lower}`) || lower.endsWith(`/${id}`);
+    });
+    if (suffix)
+        return suffix;
+    return models.find((m) => m.name?.toLowerCase() === lower);
+}
+export function matchOffering(offerings, baseURL) {
+    if (!baseURL || offerings.length === 0)
+        return undefined;
+    let host = "";
+    try {
+        host = new URL(baseURL).hostname.toLowerCase();
+    }
+    catch {
+        return undefined;
+    }
+    return offerings.find((o) => {
+        const id = String(o.providerId ?? "")
+            .toLowerCase()
+            .replace(/_/g, "-");
+        if (!id)
+            return false;
+        if (host.includes(id))
+            return true;
+        const slug = id.split("-")[0] ?? "";
+        return slug.length >= 4 && host.includes(slug);
+    });
+}
+const CANONICAL_EFFORTS = ["low", "medium", "high", "max"];
+function hasEffortLevel(parsed) {
+    return parsed.efforts.some((raw) => {
+        const canonical = parseThinkingEffort(raw);
+        return Boolean(canonical && canonical !== "off");
+    });
+}
+/** When the active host is unknown, keep levels a majority of offerings actually list. */
+export function majorityReasoning(offerings) {
+    const voters = offerings
+        .map((offering) => parseReasoningOptions(offering.reasoningOptions))
+        .filter((parsed) => parsed.toggle || parsed.efforts.length > 0);
+    if (voters.length === 0)
+        return { toggle: false, efforts: [] };
+    const effortVoters = voters.filter(hasEffortLevel);
+    const toggleThreshold = voters.length / 2;
+    const effortThreshold = effortVoters.length === 0 ? Number.POSITIVE_INFINITY : effortVoters.length / 2;
+    let toggleVotes = 0;
+    let xhighVotes = 0;
+    const votes = new Map();
+    for (const parsed of voters) {
+        if (parsed.toggle || parsed.efforts.includes("none"))
+            toggleVotes++;
+    }
+    for (const parsed of effortVoters) {
+        const seen = new Set();
+        for (const raw of parsed.efforts) {
+            if (raw === "xhigh" || raw === "extra-high")
+                xhighVotes++;
+            const canonical = parseThinkingEffort(raw);
+            if (!canonical || canonical === "off" || seen.has(canonical))
+                continue;
+            seen.add(canonical);
+            votes.set(canonical, (votes.get(canonical) ?? 0) + 1);
+        }
+    }
+    const toggle = toggleVotes >= toggleThreshold;
+    const efforts = [];
+    if (toggle)
+        efforts.push("none");
+    for (const key of CANONICAL_EFFORTS) {
+        if ((votes.get(key) ?? 0) >= effortThreshold)
+            efforts.push(key);
+    }
+    if (efforts.includes("max") && xhighVotes > 0)
+        efforts.push("xhigh");
+    return { toggle, efforts };
+}
+function contextFrom(limit) {
+    const n = limit?.context;
+    if (typeof n === "number" && Number.isFinite(n) && n >= 4096)
+        return Math.floor(n);
+    return undefined;
+}
+export function catalogFromLonaeModel(model, modelId, baseURL) {
+    const offerings = model.offerings ?? [];
+    const matched = matchOffering(offerings, baseURL);
+    const reasoning = matched ? parseReasoningOptions(matched.reasoningOptions) : majorityReasoning(offerings);
+    const contextWindow = contextFrom(matched?.limit) ?? contextFrom(model.limit);
+    return {
+        version: CATALOG_ENTRY_VERSION,
+        modelId,
+        lonaeId: model.id,
+        ...(contextWindow != null ? { contextWindow } : {}),
+        reasoning,
+        timestamp: Date.now(),
+    };
+}
+async function fetchJson(url) {
+    try {
+        const response = await fetch(url, { signal: AbortSignal.timeout(FETCH_TIMEOUT_MS) });
+        if (!response.ok)
+            return null;
+        return await response.json();
+    }
+    catch {
+        return null;
+    }
+}
+function readModel(payload) {
+    const root = isRecord(payload) ? payload : null;
+    const data = root && isRecord(root.data) ? root.data : root;
+    if (!data || typeof data.id !== "string")
+        return null;
+    const limit = isRecord(data.limit)
+        ? { context: typeof data.limit.context === "number" ? data.limit.context : undefined }
+        : undefined;
+    const offerings = Array.isArray(data.offerings)
+        ? data.offerings.filter(isRecord).map((o) => ({
+            providerId: typeof o.providerId === "string" ? o.providerId : undefined,
+            limit: isRecord(o.limit)
+                ? { context: typeof o.limit.context === "number" ? o.limit.context : undefined }
+                : undefined,
+            reasoningOptions: o.reasoningOptions,
+        }))
+        : [];
+    return {
+        id: data.id,
+        limit,
+        reasoning: data.reasoning === true,
+        offerings,
+    };
+}
+function readList(payload) {
+    const root = isRecord(payload) ? payload : null;
+    const data = root && Array.isArray(root.data) ? root.data : Array.isArray(payload) ? payload : [];
+    return data.flatMap((item) => {
+        if (!isRecord(item) || typeof item.id !== "string")
+            return [];
+        return [
+            {
+                id: item.id,
+                name: typeof item.name === "string" ? item.name : undefined,
+                context: typeof item.context === "number" ? item.context : undefined,
+            },
+        ];
+    });
+}
+function modelPath(id) {
+    return id
+        .split("/")
+        .map((part) => encodeURIComponent(part))
+        .join("/");
+}
+async function fetchLonaeModel(modelId) {
+    const base = lonaeBaseUrl();
+    if (modelId.includes("/")) {
+        const direct = readModel(await fetchJson(`${base}/api/v1/models/${modelPath(modelId)}`));
+        if (direct)
+            return direct;
+    }
+    const listed = readList(await fetchJson(`${base}/api/v1/models?q=${encodeURIComponent(modelId)}&page_size=20`));
+    const match = pickListedModel(listed, modelId);
+    if (!match)
+        return null;
+    return readModel(await fetchJson(`${base}/api/v1/models/${modelPath(match.id)}`));
+}
+/**
+ * Resolve context window and thinking options from the Lonae catalog.
+ * Successful lookups are cached in memory and on disk for 7 days.
+ */
+export async function getModelCatalog(modelId, baseURL) {
+    const cached = getCachedModelCatalog(modelId);
+    if (cached)
+        return cached;
+    const negAt = negativeCache.get(modelId);
+    if (negAt !== undefined && Date.now() - negAt <= NEGATIVE_TTL)
+        return null;
+    const pending = inFlight.get(modelId);
+    if (pending)
+        return pending;
+    const probing = fetchLonaeModel(modelId).then((model) => {
+        if (!model) {
+            negativeCache.set(modelId, Date.now());
+            return null;
+        }
+        const entry = catalogFromLonaeModel(model, modelId, baseURL);
+        setCache(modelId, entry);
+        return entry;
+    });
+    inFlight.set(modelId, probing);
+    try {
+        return await probing;
+    }
+    finally {
+        inFlight.delete(modelId);
+    }
+}

package/dist/permission-cli.js

@@ -1,4 +1,4 @@
-import { takeScopeFlags } from "./memory.js";
+import { takeScopeFlags, scopeLabel } from "./scope.js";
 import { getPermissionSnapshot, parsePermissionMode, permissionModeLabel, setPermissionMode, } from "./config.js";
 import { getPermissionOverride, setPermissionOverride } from "./confirm.js";
 export const PERMISSION_CLI_USAGE = [
@@ -8,9 +8,6 @@ export const PERMISSION_CLI_USAGE = [
 function sourceLabel(source) {
     return source === "cli" ? "this run" : source === "project" ? "project" : source === "global" ? "global" : "default";
 }
-function scopeLabel(scope) {
-    return scope === "project" ? "project" : "global";
-}
 export function runPermissionCli(input) {
     const { scope: posScope, rest } = takeScopeFlags(input.positionals);
     const scope = posScope ?? input.scope ?? "global";

package/dist/provider.js

@@ -1,6 +1,8 @@
 import { createOpenAI } from "@ai-sdk/openai";
 import { getEffectiveConfig, getActiveProvider, normalizeOllamaBaseURL } from "./config.js";
 import { createTimeoutFetch, DEFAULT_FIRST_BYTE_TIMEOUT_MS, DEFAULT_STREAM_IDLE_TIMEOUT_MS, } from "./fetch-timeout.js";
+import { foldReasoningInChatResponse } from "./reasoning-stream.js";
+import { fetchWithThinkingWire } from "./thinking-wire.js";
 function positiveMs(raw, fallback) {
     const value = typeof raw === "string" ? Number(raw) : raw;
     if (typeof value !== "number" || !Number.isFinite(value) || value < 0)
@@ -10,11 +12,12 @@ function positiveMs(raw, fallback) {
 /** Timeout/trace-aware fetch shared by every provider client. */
 export function modelFetch() {
     const cfg = getEffectiveConfig();
-    return createTimeoutFetch({
+    const inner = createTimeoutFetch({
         firstByteTimeoutMs: positiveMs(process.env.MIN_AGENT_REQUEST_TIMEOUT_MS ?? cfg.agent?.requestTimeoutMs, DEFAULT_FIRST_BYTE_TIMEOUT_MS),
         idleTimeoutMs: positiveMs(process.env.MIN_AGENT_STREAM_IDLE_TIMEOUT_MS ?? cfg.agent?.streamIdleTimeoutMs, DEFAULT_STREAM_IDLE_TIMEOUT_MS),
         trace: process.env.MIN_AGENT_TRACE === "1" || process.env.MIN_AGENT_TRACE === "true",
     });
+    return (input, init) => fetchWithThinkingWire(inner, input, init).then(foldReasoningInChatResponse);
 }
 export function resolveModelForProvider(provider, modelId) {
     if (!provider.baseURL || !provider.apiKey) {

package/dist/reasoning-stream.js

@@ -0,0 +1,158 @@
+/**
+ * OpenAI-compatible chat completions put the thinking chain in
+ * `reasoning_content` / `reasoning` / `reasoning_details`. The @ai-sdk/openai
+ * chat parser only reads `delta.content`, so those fields never become
+ * reasoning events. Fold them into `<think>` tags that ThinkingBodySplitter
+ * already turns into on-screen thinking.
+ */
+function isRecord(v) {
+    return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function sanitizeReasoning(text) {
+    return text.replace(/<\/?(?:think|thinking)>/gi, "");
+}
+function stringField(v, key) {
+    if (!isRecord(v))
+        return "";
+    return typeof v[key] === "string" ? v[key] : "";
+}
+function reasoningFromDetails(details) {
+    if (!Array.isArray(details))
+        return "";
+    return details
+        .map((item) => {
+        const text = stringField(item, "text");
+        if (text)
+            return text;
+        return stringField(item, "content");
+    })
+        .join("");
+}
+function reasoningFromValue(v) {
+    if (typeof v === "string")
+        return v;
+    if (!isRecord(v))
+        return "";
+    return stringField(v, "content") || stringField(v, "text");
+}
+export function reasoningTextFromDelta(delta) {
+    const details = reasoningFromDetails(delta.reasoning_details);
+    const primary = reasoningFromValue(delta.reasoning_content) ||
+        reasoningFromValue(delta.reasoning) ||
+        reasoningFromValue(delta.thinking);
+    return sanitizeReasoning(`${details}${primary}`);
+}
+export function createReasoningDeltaTracker() {
+    let acc = "";
+    return (text) => {
+        if (!text)
+            return "";
+        if (acc && text.startsWith(acc)) {
+            const extra = text.slice(acc.length);
+            acc = text;
+            return extra;
+        }
+        acc += text;
+        return text;
+    };
+}
+export function foldReasoningIntoDelta(delta, takeDelta) {
+    const reasoning = takeDelta(reasoningTextFromDelta(delta));
+    if (!reasoning)
+        return false;
+    const content = typeof delta.content === "string" ? delta.content : "";
+    delta.content = `<think>${reasoning}</think>${content}`;
+    return true;
+}
+export function foldReasoningInChunk(chunk, takeDelta = (t) => t) {
+    if (!isRecord(chunk) || !Array.isArray(chunk.choices))
+        return false;
+    let changed = false;
+    for (const choice of chunk.choices) {
+        if (!isRecord(choice))
+            continue;
+        if (isRecord(choice.delta) && foldReasoningIntoDelta(choice.delta, takeDelta))
+            changed = true;
+        if (isRecord(choice.message) && foldReasoningIntoDelta(choice.message, takeDelta))
+            changed = true;
+    }
+    return changed;
+}
+export function foldReasoningIntoSseLine(line, takeDelta) {
+    const trimmed = line.replace(/\r$/, "");
+    if (!trimmed.startsWith("data:"))
+        return line;
+    const payload = trimmed.slice("data:".length).trim();
+    if (!payload || payload === "[DONE]")
+        return line;
+    try {
+        const parsed = JSON.parse(payload);
+        if (!foldReasoningInChunk(parsed, takeDelta))
+            return line;
+        const prefix = line.startsWith("data: ") ? "data: " : "data:";
+        const nl = line.endsWith("\r") ? "\r" : "";
+        return `${prefix}${JSON.stringify(parsed)}${nl}`;
+    }
+    catch {
+        return line;
+    }
+}
+function rewriteSseFragment(fragment, takeDelta) {
+    const keepLastNl = fragment.endsWith("\n");
+    const raw = keepLastNl ? fragment.slice(0, -1) : fragment;
+    return (raw
+        .split("\n")
+        .map((line) => foldReasoningIntoSseLine(line, takeDelta))
+        .join("\n") + (keepLastNl ? "\n" : ""));
+}
+export function transformReasoningSse(source) {
+    const decoder = new TextDecoder();
+    const encoder = new TextEncoder();
+    const reader = source.getReader();
+    const takeDelta = createReasoningDeltaTracker();
+    let pending = "";
+    return new ReadableStream({
+        async pull(controller) {
+            for (;;) {
+                const { done, value } = await reader.read();
+                if (done) {
+                    pending += decoder.decode();
+                    if (pending)
+                        controller.enqueue(encoder.encode(rewriteSseFragment(pending, takeDelta)));
+                    controller.close();
+                    return;
+                }
+                pending += decoder.decode(value, { stream: true });
+                const nl = pending.lastIndexOf("\n");
+                if (nl < 0)
+                    continue;
+                const complete = pending.slice(0, nl + 1);
+                pending = pending.slice(nl + 1);
+                controller.enqueue(encoder.encode(rewriteSseFragment(complete, takeDelta)));
+                return;
+            }
+        },
+        cancel(reason) {
+            return reader.cancel(reason);
+        },
+    });
+}
+function isChatSseResponse(response) {
+    const ctype = (response.headers.get("content-type") ?? "").toLowerCase();
+    if (ctype.includes("event-stream"))
+        return true;
+    if (!ctype || ctype.startsWith("text/plain"))
+        return true;
+    return false;
+}
+export function foldReasoningInChatResponse(response) {
+    if (!response.body || response.status >= 400)
+        return response;
+    if (!isChatSseResponse(response))
+        return response;
+    return new Response(transformReasoningSse(response.body), {
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers,
+    });
+}

package/dist/sandbox-cli.js

@@ -1,4 +1,4 @@
-import { takeScopeFlags } from "./memory.js";
+import { takeScopeFlags, scopeLabel } from "./scope.js";
 import { getSandboxSnapshot, setSandboxConfig } from "./config.js";
 import { parseNetworkPolicy, parseSandboxMode, getEffectiveSandboxPolicy, sandboxEnforcementCaveat, sandboxModeLabel, sandboxStatusLabel, setSandboxOverride, } from "./sandbox.js";
 export const SANDBOX_CLI_USAGE = [
@@ -17,9 +17,6 @@ function sourceLabel(source) {
                     ? "global"
                     : "default";
 }
-function scopeLabel(scope) {
-    return scope === "project" ? "project" : "global";
-}
 export function runSandboxCli(input) {
     const { scope: posScope, rest } = takeScopeFlags(input.positionals);
     const scope = posScope ?? input.scope ?? "global";

package/dist/scope.js

@@ -0,0 +1,23 @@
+export function readScope(value) {
+    if (value === undefined || value === null || value === "")
+        return { ok: true, scope: undefined };
+    if (value === "global" || value === "project")
+        return { ok: true, scope: value };
+    return { ok: false };
+}
+export function takeScopeFlags(tokens) {
+    let scope;
+    const rest = [];
+    for (const t of tokens) {
+        if (t === "--project")
+            scope = "project";
+        else if (t === "--global")
+            scope = "global";
+        else
+            rest.push(t);
+    }
+    return { scope, rest };
+}
+export function scopeLabel(scope) {
+    return scope === "project" ? "project" : "global";
+}

package/dist/serve/common.js

@@ -1,7 +1,9 @@
 import { randomUUID } from "crypto";
-import { getSandboxSnapshot, getPermissionSnapshot, permissionModeLabel } from "../config.js";
+import { getSandboxSnapshot, getPermissionSnapshot, permissionModeLabel, parseThinkingEffort, parseMemoryMode, } from "../config.js";
 import { parseNetworkPolicy, parseSandboxMode, runWithSandboxPolicy } from "../sandbox.js";
 import { runWithConfirmContext, getPermissionOverride } from "../confirm.js";
+import { thinkingPayload } from "../thinking.js";
+import { memoryPayload } from "../memory.js";
 import { runOnceWithSystem } from "../agent.js";
 import { saveSession, sanitizeForStorage } from "../sessions.js";
 import { createSaveThrottle } from "../save-throttle.js";
@@ -266,6 +268,23 @@ export function permissionPayload() {
         label: permissionModeLabel(permission),
     };
 }
+export { thinkingPayload, memoryPayload };
+export function readThinking(body) {
+    if (body.thinking === undefined)
+        return { ok: true };
+    const thinking = parseThinkingEffort(body.thinking);
+    if (!thinking)
+        return { ok: false, error: "invalid_thinking", detail: "thinking must be off, low, medium, high, or max" };
+    return { ok: true, thinking };
+}
+export function readMemory(body) {
+    if (body.memory === undefined)
+        return { ok: true };
+    const memory = parseMemoryMode(body.memory);
+    if (!memory)
+        return { ok: false, error: "invalid_memory", detail: "memory must be on or off" };
+    return { ok: true, memory };
+}
 export function normalizeMessages(body) {
     if (body.messages && Array.isArray(body.messages)) {
         if (body.messages.length === 0)
@@ -282,6 +301,8 @@ export function chatRunOptions(body) {
         temperature: typeof body.temperature === "number" ? body.temperature : undefined,
         maxTokens: typeof body.maxTokens === "number" ? body.maxTokens : undefined,
         topP: typeof body.topP === "number" ? body.topP : undefined,
+        thinking: parseThinkingEffort(body.thinking),
+        memory: parseMemoryMode(body.memory),
         providerName: typeof body.provider === "string" ? body.provider : undefined,
         ...(body.plan_mode === true ? { planMode: true } : {}),
     };

package/dist/serve/routes-chat.js

@@ -5,7 +5,7 @@ import { lastUserText } from "../tui/hydrate.js";
 import { compactMessages } from "../compaction.js";
 import { resolveModel } from "../provider.js";
 import { emptyTaskState } from "../tools/todo.js";
-import { MAX_CONCURRENT_CHATS, sendJson, sendJsonError, readJsonBody, readSandboxTighten, normalizeMessages, chatRunOptions, executeChat, } from "./common.js";
+import { MAX_CONCURRENT_CHATS, sendJson, sendJsonError, readJsonBody, readSandboxTighten, readThinking, readMemory, normalizeMessages, chatRunOptions, executeChat, } from "./common.js";
 /** Shared handler for /v1/chat and /v1/code (streaming + JSON). */
 async function handleChatRequest(ctx, req, res) {
     if (req.headers["content-type"]?.split(";")[0]?.trim() !== "application/json") {
@@ -33,6 +33,16 @@ async function handleChatRequest(ctx, req, res) {
             return;
         }
         const sandboxTighten = sandboxParsed.policy;
+        const thinkingParsed = readThinking(body);
+        if (!thinkingParsed.ok) {
+            sendJson(res, 400, { error: thinkingParsed.error, detail: thinkingParsed.detail });
+            return;
+        }
+        const memoryParsed = readMemory(body);
+        if (!memoryParsed.ok) {
+            sendJson(res, 400, { error: memoryParsed.error, detail: memoryParsed.detail });
+            return;
+        }
         const modelId = typeof body.model === "string" ? body.model : undefined;
         const stream = body.stream === true;
         const sessionId = typeof body.session_id === "string" ? body.session_id : undefined;
@@ -132,6 +142,11 @@ export const handleChatRoutes = async (req, res, ctx, _url, pathname) => {
             sendJson(res, 400, { error: sandboxParsed.error, detail: sandboxParsed.detail });
             return true;
         }
+        const thinkingParsed = readThinking(body);
+        if (!thinkingParsed.ok) {
+            sendJson(res, 400, { error: thinkingParsed.error, detail: thinkingParsed.detail });
+            return true;
+        }
         if (ctx.activeChats >= MAX_CONCURRENT_CHATS) {
             sendJson(res, 429, {
                 error: "too_many_concurrent_requests",
@@ -242,6 +257,11 @@ export const handleChatRoutes = async (req, res, ctx, _url, pathname) => {
             sendJson(res, 400, { error: sandboxParsed.error, detail: sandboxParsed.detail });
             return true;
         }
+        const thinkingParsed = readThinking(body);
+        if (!thinkingParsed.ok) {
+            sendJson(res, 400, { error: thinkingParsed.error, detail: thinkingParsed.detail });
+            return true;
+        }
         const imageBuffer = Buffer.from(body.image_base64, "base64");
         const mimeType = body.mime_type ?? "image/png";
         const text = body.message ?? "What's in this image?";

package/dist/serve/routes-memory.js

@@ -1,8 +1,37 @@
-import { loadMemories, addMemory, deleteMemory, searchMemories, readMemoryScope } from "../memory.js";
+import { loadMemories, addMemory, deleteMemory, searchMemories, readMemoryScope, parseMemoryMode, setMemoryMode, memoryPayload, } from "../memory.js";
 import { sendJson, sendJsonError, readJsonBody } from "./common.js";
 export const handleMemoryRoutes = async (req, res, _ctx, url, pathname) => {
+    if (req.method === "GET" && pathname === "/v1/memory/mode") {
+        sendJson(res, 200, memoryPayload());
+        return true;
+    }
+    if (req.method === "POST" && pathname === "/v1/memory/mode") {
+        const parsed = await readJsonBody(req);
+        if (!parsed.ok) {
+            sendJsonError(res, parsed);
+            return true;
+        }
+        const mode = parseMemoryMode(parsed.value.memory);
+        if (!mode) {
+            sendJson(res, 400, { error: "invalid_memory", detail: "memory must be on or off" });
+            return true;
+        }
+        const scopeParsed = readMemoryScope(parsed.value.scope);
+        if (!scopeParsed.ok) {
+            sendJson(res, 400, { error: "invalid_scope", allowed: ["global", "project"] });
+            return true;
+        }
+        const scope = scopeParsed.scope ?? "global";
+        setMemoryMode(mode, scope);
+        sendJson(res, 200, { ok: true, scope, ...memoryPayload() });
+        return true;
+    }
     if (req.method === "GET" && pathname === "/v1/memory") {
-        sendJson(res, 200, { memories: loadMemories("global"), project_memories: loadMemories("project") });
+        sendJson(res, 200, {
+            ...memoryPayload(),
+            memories: loadMemories("global"),
+            project_memories: loadMemories("project"),
+        });
         return true;
     }
     if (req.method === "POST" && pathname === "/v1/memory") {