min-agent 0.4.0 → 0.5.0

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") {

package/dist/serve/routes-meta.js

@@ -1,12 +1,13 @@
-import { fetchModels, getActiveProvider, getEffectiveConfig, getBudgetSnapshot, setBudgetMaxCost, setSandboxConfig, setPermissionMode, parsePermissionMode, } from "../config.js";
+import { fetchModels, getActiveProvider, getEffectiveConfig, getBudgetSnapshot, setBudgetMaxCost, setSandboxConfig, setPermissionMode, parsePermissionMode, parseThinkingEffort, } from "../config.js";
+import { setThinkingEffort } from "../thinking.js";
 import { parseNetworkPolicy, parseSandboxMode } from "../sandbox.js";
-import { readMemoryScope } from "../memory.js";
+import { readScope } from "../scope.js";
 import { getWorkingTreeDiff } from "../tui/diff-view.js";
 import { scanProject } from "../code-mode.js";
 import { getContextWindowInfo } from "../context-window.js";
 import { getModelPrice, estimateCost } from "../pricing.js";
 import { checkForUpdate } from "../updater.js";
-import { sendJson, sendJsonError, readJsonBody, readStringPathList, sandboxPayload, permissionPayload, } from "./common.js";
+import { sendJson, sendJsonError, readJsonBody, readStringPathList, sandboxPayload, permissionPayload, thinkingPayload, memoryPayload, } from "./common.js";
 export const handleMetaRoutes = async (req, res, ctx, url, pathname) => {
     if (req.method === "GET" && pathname === "/health") {
         sendJson(res, 200, { ok: true, service: "min-agent", version: ctx.version });
@@ -19,6 +20,8 @@ export const handleMetaRoutes = async (req, res, ctx, url, pathname) => {
             instructions_chars: ctx.instructions.join("\n").length,
             sandbox: sandboxPayload(),
             permission: permissionPayload(),
+            thinking: thinkingPayload(),
+            memory: memoryPayload(),
         });
         return true;
     }
@@ -64,7 +67,7 @@ export const handleMetaRoutes = async (req, res, ctx, url, pathname) => {
             sendJson(res, 400, { error: "invalid_max_cost", detail: "maxCostUSD must be a positive number" });
             return true;
         }
-        const scopeParsed = readMemoryScope(parsed.value.scope);
+        const scopeParsed = readScope(parsed.value.scope);
         if (!scopeParsed.ok) {
             sendJson(res, 400, { error: "invalid_scope", allowed: ["global", "project"] });
             return true;
@@ -94,7 +97,7 @@ export const handleMetaRoutes = async (req, res, ctx, url, pathname) => {
             sendJson(res, 400, { error: "invalid_permission", detail: "permission must be ask, accept-edits, or allow-all" });
             return true;
         }
-        const scopeParsed = readMemoryScope(parsed.value.scope);
+        const scopeParsed = readScope(parsed.value.scope);
         if (!scopeParsed.ok) {
             sendJson(res, 400, { error: "invalid_scope", allowed: ["global", "project"] });
             return true;
@@ -104,6 +107,31 @@ export const handleMetaRoutes = async (req, res, ctx, url, pathname) => {
         sendJson(res, 200, { ok: true, scope, ...permissionPayload() });
         return true;
     }
+    if (req.method === "GET" && pathname === "/v1/thinking") {
+        sendJson(res, 200, thinkingPayload());
+        return true;
+    }
+    if (req.method === "POST" && pathname === "/v1/thinking") {
+        const parsed = await readJsonBody(req);
+        if (!parsed.ok) {
+            sendJsonError(res, parsed);
+            return true;
+        }
+        const effort = parseThinkingEffort(parsed.value.thinking);
+        if (!effort) {
+            sendJson(res, 400, { error: "invalid_thinking", detail: "thinking must be off, low, medium, high, or max" });
+            return true;
+        }
+        const scopeParsed = readScope(parsed.value.scope);
+        if (!scopeParsed.ok) {
+            sendJson(res, 400, { error: "invalid_scope", allowed: ["global", "project"] });
+            return true;
+        }
+        const scope = scopeParsed.scope ?? "global";
+        setThinkingEffort(effort, scope);
+        sendJson(res, 200, { ok: true, scope, ...thinkingPayload() });
+        return true;
+    }
     if (req.method === "POST" && pathname === "/v1/sandbox") {
         const parsed = await readJsonBody(req);
         if (!parsed.ok) {
@@ -134,7 +162,7 @@ export const handleMetaRoutes = async (req, res, ctx, url, pathname) => {
             sendJson(res, 400, { error: "invalid_body", detail: "Provide mode, network, extraWriteRoots, or extraReadRoots" });
             return true;
         }
-        const scopeParsed = readMemoryScope(body.scope);
+        const scopeParsed = readScope(body.scope);
         if (!scopeParsed.ok) {
             sendJson(res, 400, { error: "invalid_scope", allowed: ["global", "project"] });
             return true;

package/dist/think-cli.js

@@ -0,0 +1,36 @@
+import { takeScopeFlags, scopeLabel } from "./scope.js";
+import { parseThinkingEffort, resolveThinkingEffort, setThinkingEffort, setThinkingOverride, thinkingEffortLabel, } from "./thinking.js";
+export const THINK_CLI_USAGE = [
+    "Usage: min-agent think [off|low|medium|high|max] [--project|--global]",
+    "       min-agent --think off|low|medium|high|max [--project|--global]",
+].join("\n");
+function sourceLabel(source) {
+    return source === "cli" ? "this run" : source === "project" ? "project" : source === "global" ? "global" : "default";
+}
+export function runThinkCli(input) {
+    const { scope: posScope, rest } = takeScopeFlags(input.positionals);
+    const scope = posScope ?? input.scope ?? "global";
+    if (rest[0] === "--help" || rest[0] === "-h") {
+        return { ok: true, lines: [THINK_CLI_USAGE] };
+    }
+    if (rest.length === 1) {
+        const parsed = parseThinkingEffort(rest[0]);
+        if (!parsed)
+            return { ok: false, lines: [THINK_CLI_USAGE] };
+        setThinkingEffort(parsed, scope);
+        setThinkingOverride(parsed);
+        return { ok: true, lines: [`✓ Thinking set to ${thinkingEffortLabel(parsed)} (${scopeLabel(scope)})`] };
+    }
+    if (rest.length > 1)
+        return { ok: false, lines: [THINK_CLI_USAGE] };
+    if (input.flagEffort) {
+        setThinkingEffort(input.flagEffort, scope);
+        setThinkingOverride(input.flagEffort);
+        return { ok: true, lines: [`✓ Thinking set to ${thinkingEffortLabel(input.flagEffort)} (${scopeLabel(scope)})`] };
+    }
+    const { thinking, source } = resolveThinkingEffort();
+    return {
+        ok: true,
+        lines: [`Current thinking: ${thinkingEffortLabel(thinking)} (${sourceLabel(source)})`, THINK_CLI_USAGE],
+    };
+}