min-agent 0.1.4 → 0.1.6

package/dist/mcp.js

@@ -2,28 +2,52 @@ import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+import { UnauthorizedError } from "@modelcontextprotocol/sdk/client/auth.js";
 import { tool, jsonSchema } from "ai";
 import { readFileSync, existsSync, writeFileSync, mkdirSync } from "fs";
 import path from "path";
 import { truncateToolOutput } from "./tool-output.js";
+import { getConfigDir } from "./config.js";
 const DEFAULT_TIMEOUT = 30000;
 function getMcpConfigPath() {
-    return path.join(process.cwd(), ".min-agent", "mcp.json");
+    // Check project-local first, then global
+    const local = path.join(process.cwd(), ".min-agent", "mcp.json");
+    if (existsSync(local))
+        return local;
+    return path.join(getConfigDir(), "mcp.json");
+}
+function getMcpConfigWritePath() {
+    // Write to project-local if it exists, otherwise global
+    const local = path.join(process.cwd(), ".min-agent", "mcp.json");
+    if (existsSync(path.dirname(local)))
+        return local;
+    return path.join(getConfigDir(), "mcp.json");
 }
 let connectedServers = {};
 export function loadMcpConfig() {
-    const configPath = getMcpConfigPath();
-    if (!existsSync(configPath))
-        return { mcpServers: {} };
-    try {
-        return JSON.parse(readFileSync(configPath, "utf-8"));
+    const globalPath = path.join(getConfigDir(), "mcp.json");
+    const localPath = path.join(process.cwd(), ".min-agent", "mcp.json");
+    let config = { mcpServers: {} };
+    // Load global first
+    if (existsSync(globalPath)) {
+        try {
+            const global = JSON.parse(readFileSync(globalPath, "utf-8"));
+            config.mcpServers = { ...config.mcpServers, ...global.mcpServers };
+        }
+        catch { }
     }
-    catch {
-        return { mcpServers: {} };
+    // Local overrides global
+    if (existsSync(localPath) && localPath !== globalPath) {
+        try {
+            const local = JSON.parse(readFileSync(localPath, "utf-8"));
+            config.mcpServers = { ...config.mcpServers, ...local.mcpServers };
+        }
+        catch { }
     }
+    return config;
 }
 export function saveMcpConfig(config) {
-    const configPath = getMcpConfigPath();
+    const configPath = path.join(getConfigDir(), "mcp.json");
     const dir = path.dirname(configPath);
     mkdirSync(dir, { recursive: true });
     writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
@@ -42,7 +66,21 @@ function buildRemoteRequestInit(config) {
     return { headers };
 }
 async function openStdioMcpServer(name, config) {
-    const [cmd, ...args] = config.command ?? [];
+    // Support both formats:
+    // { command: ["uvx", "mcp-server-time"] }           — min-agent native
+    // { command: "uvx", args: ["mcp-server-time"] }     — opencode/claude style
+    let cmd;
+    let args;
+    if (Array.isArray(config.command)) {
+        [cmd, ...args] = config.command;
+    }
+    else if (typeof config.command === "string") {
+        cmd = config.command;
+        args = config.args ?? [];
+    }
+    else {
+        throw new Error(`MCP "${name}" has empty command`);
+    }
     if (!cmd) {
         throw new Error(`MCP "${name}" has empty command`);
     }
@@ -52,7 +90,7 @@ async function openStdioMcpServer(name, config) {
         env: { ...process.env, ...(config.environment ?? {}) },
         stderr: "pipe",
     });
-    const client = new Client({ name: "agent-demo", version: "0.0.1" });
+    const client = new Client({ name: "min-agent", version: "0.1.0" });
     await client.connect(transport);
     const { tools } = await client.listTools();
     return { client, transport, tools };
@@ -75,37 +113,48 @@ async function openRemoteMcpServer(name, config) {
     const requestInit = buildRemoteRequestInit(config);
     const mode = config.remoteTransport ?? "auto";
     const connectStreamable = async () => {
-        const client = new Client({ name: "agent-demo", version: "0.0.1" });
+        const client = new Client({ name: "min-agent", version: "0.1.0" });
         const transport = new StreamableHTTPClientTransport(baseUrl, requestInit ? { requestInit } : undefined);
         await client.connect(transport);
         const { tools } = await client.listTools();
         return { client, transport, tools };
     };
     const connectSse = async () => {
-        const client = new Client({ name: "agent-demo", version: "0.0.1" });
+        const client = new Client({ name: "min-agent", version: "0.1.0" });
         const transport = new SSEClientTransport(baseUrl, requestInit ? { requestInit } : undefined);
         await client.connect(transport);
         const { tools } = await client.listTools();
         return { client, transport, tools };
     };
-    if (mode === "streamable-http") {
-        return await connectStreamable();
-    }
-    if (mode === "sse") {
-        return await connectSse();
-    }
-    // auto: prefer streamable-http, fall back to sse (older servers)
     try {
-        return await connectStreamable();
-    }
-    catch (firstErr) {
-        try {
+        if (mode === "streamable-http")
+            return await connectStreamable();
+        if (mode === "sse")
             return await connectSse();
+        // auto: prefer streamable-http, fall back to sse
+        try {
+            return await connectStreamable();
         }
-        catch {
-            throw new Error(`MCP "${name}" remote connection failed (streamable-http + sse): ${firstErr?.message ?? String(firstErr)}`);
+        catch (firstErr) {
+            try {
+                return await connectSse();
+            }
+            catch {
+                throw firstErr;
+            }
         }
     }
+    catch (err) {
+        // Handle OAuth/Unauthorized errors
+        if (err instanceof UnauthorizedError || err?.message?.includes("Unauthorized") || err?.message?.includes("401")) {
+            if (config.oauth === false) {
+                throw new Error(`MCP "${name}" requires authentication but OAuth is disabled in config`);
+            }
+            throw new Error(`MCP "${name}" requires authentication. Add a "token" field to the server config, or configure OAuth:\n` +
+                `  min-agent mcp add ${name} --url ${rawUrl} --token YOUR_TOKEN`);
+        }
+        throw new Error(`MCP "${name}" remote connection failed: ${err?.message ?? String(err)}`);
+    }
 }
 async function openMcpServer(name, config) {
     if (isRemoteMcpConfig(config)) {
@@ -119,13 +168,18 @@ export function formatMcpServerBinding(config) {
         const mode = config.remoteTransport ?? "auto";
         return `${config.url} [remote:${mode}]`;
     }
-    return (config.command ?? []).join(" ");
+    const cmd = Array.isArray(config.command) ? config.command.join(" ") : `${config.command ?? ""} ${(config.args ?? []).join(" ")}`.trim();
+    return cmd || "(no command)";
 }
 export async function connectMcpServer(name, config) {
     if (config.enabled === false)
         return null;
+    const timeout = config.timeout ?? DEFAULT_TIMEOUT;
     try {
-        const server = await openMcpServer(name, config);
+        const server = await Promise.race([
+            openMcpServer(name, config),
+            new Promise((_, reject) => setTimeout(() => reject(new Error(`connection timed out after ${timeout}ms`)), timeout)),
+        ]);
         console.log(`\x1b[90m  MCP "${name}" connected (${server.tools.length} tools)\x1b[0m`);
         return server;
     }

package/dist/output.js

@@ -32,11 +32,24 @@ export function printToolResult(name, result) {
     const suffix = truncated ? ` (${lines.length - maxLines} more lines)` : "";
     console.log(`${COLORS.green}  ✓${COLORS.reset} ${COLORS.dim}${display}${suffix}${COLORS.reset}\n`);
 }
-export function printDone(steps, usage) {
+export function printDone(steps, usage, contextWindow) {
     const input = usage.inputTokens ?? 0;
     const output = usage.outputTokens ?? 0;
     const total = input + output;
-    console.log(`${COLORS.dim}Done in ${steps} step(s) | Tokens: ${input} in / ${output} out / ${total} total${COLORS.reset}`);
+    let contextInfo = "";
+    if (input > 0 && contextWindow && contextWindow > 0) {
+        const pct = Math.round((input / contextWindow) * 100);
+        const bar = renderBar(pct);
+        contextInfo = ` | Context: ${bar} ${pct}%`;
+    }
+    console.log(`${COLORS.dim}Done in ${steps} step(s) | Tokens: ${input} in / ${output} out / ${total} total${contextInfo}${COLORS.reset}`);
+}
+function renderBar(pct) {
+    const width = 10;
+    const filled = Math.round((pct / 100) * width);
+    const empty = width - filled;
+    const color = pct >= 80 ? "\x1b[31m" : pct >= 50 ? "\x1b[33m" : "\x1b[32m";
+    return `${color}${"█".repeat(filled)}${"░".repeat(empty)}\x1b[0m\x1b[90m`;
 }
 function formatArgs(args) {
     if (!args || typeof args !== "object")

package/dist/paste-handler.js

@@ -0,0 +1,41 @@
+/**
+ * Paste handler for large text input.
+ *
+ * When the user pastes large content (multi-line or >150 chars),
+ * shows a collapsed summary in the terminal but preserves the full
+ * text for sending to the model.
+ *
+ * Based on opencode's paste handling in the TUI prompt component.
+ */
+const PASTE_LINE_THRESHOLD = 3;
+const PASTE_CHAR_THRESHOLD = 150;
+const PREVIEW_LINES = 3;
+/**
+ * Process input text and detect if it's a large paste.
+ * Returns the full text plus display metadata.
+ */
+export function processPastedInput(text) {
+    const lineCount = (text.match(/\n/g)?.length ?? 0) + 1;
+    if (lineCount < PASTE_LINE_THRESHOLD && text.length <= PASTE_CHAR_THRESHOLD) {
+        return { fullText: text, isLargePaste: false };
+    }
+    const lines = text.split("\n");
+    const preview = lines.slice(0, PREVIEW_LINES).join("\n");
+    const remaining = lineCount - PREVIEW_LINES;
+    return {
+        fullText: text,
+        isLargePaste: true,
+        summary: remaining > 0
+            ? `${preview}\n\x1b[90m  ... (${remaining} more lines, ~${text.length} chars total)\x1b[0m`
+            : `\x1b[90m[Pasted ${text.length} chars]\x1b[0m`,
+    };
+}
+/**
+ * Print paste feedback to the user.
+ */
+export function printPasteFeedback(result) {
+    if (!result.isLargePaste)
+        return;
+    const lineCount = (result.fullText.match(/\n/g)?.length ?? 0) + 1;
+    console.log(`\x1b[90m  📋 Pasted ~${lineCount} lines (${result.fullText.length} chars)\x1b[0m`);
+}

package/dist/serve.js

@@ -5,13 +5,18 @@
 import { createServer } from "http";
 import { readFileSync, existsSync } from "fs";
 import path from "path";
-import { initMcp, shutdownMcp } from "./mcp.js";
-import { discoverSkills } from "./skills.js";
+import { initMcp, shutdownMcp, getMcpStatus } from "./mcp.js";
+import { discoverSkills, getSkills } from "./skills.js";
 import { loadInstructions } from "./instructions.js";
 import { loadConfig, fetchModels, isConfigured } from "./config.js";
 import { setAutoApprove } from "./confirm.js";
 import { runOnce, buildUserContent } from "./agent.js";
-import { loadSession, saveSession } from "./sessions.js";
+import { loadSession, saveSession, listSessions, deleteSession } from "./sessions.js";
+import { loadMemories, addMemory, deleteMemory, searchMemories } from "./memory.js";
+import { scanProject } from "./code-mode.js";
+import { compactMessages } from "./compaction.js";
+import { resolveModel } from "./provider.js";
+import { getContextWindow } from "./context-window.js";
 const MAX_BODY_BYTES = 2 * 1024 * 1024;
 const MAX_TOOL_RESULT_SSE_CHARS = 48_000;
 function packageVersion() {
@@ -328,6 +333,349 @@ export async function runServe(opts = {}) {
                 });
                 return;
             }
+            // ─── Sessions ──────────────────────────────────────────────────────
+            if (req.method === "GET" && pathname === "/v1/sessions") {
+                const sessions = listSessions();
+                sendJson(res, 200, { sessions });
+                return;
+            }
+            if (req.method === "DELETE" && pathname.startsWith("/v1/sessions/")) {
+                const id = pathname.slice("/v1/sessions/".length);
+                if (!id) {
+                    sendJson(res, 400, { error: "missing_session_id" });
+                    return;
+                }
+                const ok = deleteSession(id);
+                if (!ok) {
+                    sendJson(res, 404, { error: "session_not_found", session_id: id });
+                    return;
+                }
+                sendJson(res, 200, { ok: true, deleted: id });
+                return;
+            }
+            // ─── Memory ────────────────────────────────────────────────────────
+            if (req.method === "GET" && pathname === "/v1/memory") {
+                const memories = loadMemories();
+                sendJson(res, 200, { memories });
+                return;
+            }
+            if (req.method === "POST" && pathname === "/v1/memory") {
+                const raw = await readBody(req);
+                const body = JSON.parse(raw);
+                if (!body.content) {
+                    sendJson(res, 400, { error: "missing_content" });
+                    return;
+                }
+                const memory = addMemory(body.content, body.tags ?? []);
+                sendJson(res, 201, { ok: true, memory });
+                return;
+            }
+            if (req.method === "GET" && pathname === "/v1/memory/search") {
+                const query = url.searchParams.get("q") ?? "";
+                if (!query) {
+                    sendJson(res, 400, { error: "missing_query_param_q" });
+                    return;
+                }
+                const results = searchMemories(query);
+                sendJson(res, 200, { results });
+                return;
+            }
+            if (req.method === "DELETE" && pathname.startsWith("/v1/memory/")) {
+                const idx = parseInt(pathname.slice("/v1/memory/".length));
+                if (isNaN(idx)) {
+                    sendJson(res, 400, { error: "invalid_index" });
+                    return;
+                }
+                const ok = deleteMemory(idx - 1);
+                if (!ok) {
+                    sendJson(res, 404, { error: "memory_not_found", index: idx });
+                    return;
+                }
+                sendJson(res, 200, { ok: true, deleted: idx });
+                return;
+            }
+            // ─── MCP ───────────────────────────────────────────────────────────
+            if (req.method === "GET" && pathname === "/v1/mcp") {
+                const status = getMcpStatus();
+                sendJson(res, 200, { servers: status });
+                return;
+            }
+            // ─── Skills ────────────────────────────────────────────────────────
+            if (req.method === "GET" && pathname === "/v1/skills") {
+                const skills = getSkills();
+                sendJson(res, 200, {
+                    skills: skills.map((s) => ({ name: s.name, description: s.description, location: s.location })),
+                });
+                return;
+            }
+            // ─── Rules ─────────────────────────────────────────────────────────
+            if (req.method === "GET" && pathname === "/v1/rules") {
+                sendJson(res, 200, {
+                    count: instructions.length,
+                    rules: instructions.map((inst) => {
+                        const firstLine = inst.split("\n")[0] ?? "";
+                        return { source: firstLine.replace("Instructions from: ", ""), chars: inst.length };
+                    }),
+                });
+                return;
+            }
+            // ─── Project (code mode scan) ──────────────────────────────────────
+            if (req.method === "GET" && pathname === "/v1/project") {
+                const project = scanProject();
+                sendJson(res, 200, { project });
+                return;
+            }
+            // ─── Code mode chat ────────────────────────────────────────────────
+            if (req.method === "POST" && pathname === "/v1/code") {
+                if (req.headers["content-type"]?.split(";")[0]?.trim() !== "application/json") {
+                    sendJson(res, 415, { error: "unsupported_media_type" });
+                    return;
+                }
+                let raw;
+                try {
+                    raw = await readBody(req);
+                }
+                catch {
+                    sendJson(res, 413, { error: "payload_too_large" });
+                    return;
+                }
+                let body;
+                try {
+                    body = JSON.parse(raw);
+                }
+                catch {
+                    sendJson(res, 400, { error: "invalid_json" });
+                    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;
+                // Build code-mode system prompt
+                const { buildCodeSystemPrompt } = await import("./code-mode.js");
+                const project = scanProject();
+                const codeSystemPrompt = buildCodeSystemPrompt(project, instructions);
+                let messages;
+                if (sessionId) {
+                    const session = loadSession(sessionId);
+                    if (!session) {
+                        sendJson(res, 404, { error: "session_not_found", session_id: sessionId });
+                        return;
+                    }
+                    if (!body.message) {
+                        sendJson(res, 400, { error: "session_requires_message" });
+                        return;
+                    }
+                    messages = [...session.messages];
+                    const content = body.images?.length ? await buildUserContent(body.message, body.images) : body.message;
+                    messages.push({ role: "user", content });
+                }
+                else {
+                    const norm = normalizeMessages(body);
+                    if (!norm.ok) {
+                        sendJson(res, 400, { error: "invalid_body", detail: norm.error });
+                        return;
+                    }
+                    messages = norm.messages;
+                }
+                const abort = new AbortController();
+                req.on("close", () => abort.abort());
+                // Use runOnce with code system prompt override
+                const { runOnceWithSystem } = await import("./agent.js");
+                if (stream) {
+                    res.writeHead(200, { "Content-Type": "text/event-stream; charset=utf-8", "Cache-Control": "no-cache", Connection: "keep-alive", ...c });
+                    res.flushHeaders?.();
+                    const callbacks = {
+                        onAssistantDisplayDelta(delta) { sseWrite(res, { type: "assistant", text: delta }); },
+                        onThinkingDelta(delta) { sseWrite(res, { type: "thinking", text: delta }); },
+                        onToolCall(name, input) { sseWrite(res, { type: "tool_call", name, input }); },
+                        onToolResult(name, output) { sseWrite(res, { type: "tool_result", name, output: truncateForJson(output, MAX_TOOL_RESULT_SSE_CHARS) }); },
+                        onCompaction(line) { sseWrite(res, { type: "compaction", line }); },
+                        onStreamError(message) { sseWrite(res, { type: "error", message }); },
+                        onRunFinish(info) {
+                            let saved;
+                            if (sessionId && messages.length > 0) {
+                                try {
+                                    saved = saveSession(messages, sessionId);
+                                }
+                                catch { }
+                            }
+                            sseWrite(res, { type: "done", step_count: info.stepCount, usage: info.usage, has_error: info.hasError, session_id: saved, messages, mode: "code", project });
+                            if (!res.writableEnded)
+                                res.end();
+                        },
+                    };
+                    try {
+                        await runOnceWithSystem(messages, codeSystemPrompt, modelId, abort.signal, callbacks);
+                    }
+                    catch (err) {
+                        if (!res.writableEnded) {
+                            sseWrite(res, { type: "fatal", message: err?.message ?? String(err) });
+                            res.end();
+                        }
+                    }
+                }
+                else {
+                    const toolCalls = [];
+                    const toolResults = [];
+                    const finishBox = { info: null };
+                    await runOnceWithSystem(messages, codeSystemPrompt, modelId, abort.signal, {
+                        onToolCall(name, input) { toolCalls.push({ name, input }); },
+                        onToolResult(name, output) { toolResults.push({ name, output: truncateForJson(output, MAX_TOOL_RESULT_SSE_CHARS) }); },
+                        onRunFinish(info) { finishBox.info = info; },
+                    });
+                    const lastAssistant = [...messages].reverse().find((m) => m.role === "assistant");
+                    let saved;
+                    if (sessionId && messages.length > 0) {
+                        try {
+                            saved = saveSession(messages, sessionId);
+                        }
+                        catch { }
+                    }
+                    const fi = finishBox.info;
+                    sendJson(res, 200, { mode: "code", project, messages, assistant: lastAssistant ?? null, tool_calls: toolCalls, tool_results: toolResults, session_id: saved, step_count: fi?.stepCount ?? 0, usage: fi?.usage ?? null, has_error: fi?.hasError ?? false });
+                }
+                return;
+            }
+            // ─── MCP management ────────────────────────────────────────────────
+            if (req.method === "POST" && pathname === "/v1/paste") {
+                if (req.headers["content-type"]?.split(";")[0]?.trim() !== "application/json") {
+                    sendJson(res, 415, { error: "unsupported_media_type" });
+                    return;
+                }
+                const raw = await readBody(req);
+                const body = JSON.parse(raw);
+                if (!body.image_base64) {
+                    sendJson(res, 400, { error: "missing_image_base64" });
+                    return;
+                }
+                const imageBuffer = Buffer.from(body.image_base64, "base64");
+                const mimeType = body.mime_type ?? "image/png";
+                const text = body.message ?? "What's in this image?";
+                const modelId = body.model;
+                const sessionId = body.session_id;
+                const stream = body.stream === true;
+                let messages = [];
+                if (sessionId) {
+                    const session = loadSession(sessionId);
+                    if (session)
+                        messages = [...session.messages];
+                }
+                const content = [
+                    { type: "text", text },
+                    { type: "image", image: imageBuffer, mimeType },
+                ];
+                messages.push({ role: "user", content });
+                const abort = new AbortController();
+                req.on("close", () => abort.abort());
+                if (stream) {
+                    res.writeHead(200, { "Content-Type": "text/event-stream; charset=utf-8", "Cache-Control": "no-cache", Connection: "keep-alive", ...c });
+                    res.flushHeaders?.();
+                    const callbacks = {
+                        onAssistantDisplayDelta(delta) { sseWrite(res, { type: "assistant", text: delta }); },
+                        onThinkingDelta(delta) { sseWrite(res, { type: "thinking", text: delta }); },
+                        onToolCall(name, input) { sseWrite(res, { type: "tool_call", name, input }); },
+                        onToolResult(name, output) { sseWrite(res, { type: "tool_result", name, output: truncateForJson(output, MAX_TOOL_RESULT_SSE_CHARS) }); },
+                        onStreamError(message) { sseWrite(res, { type: "error", message }); },
+                        onRunFinish(info) {
+                            let saved;
+                            if (sessionId) {
+                                try {
+                                    saved = saveSession(messages, sessionId);
+                                }
+                                catch { }
+                            }
+                            sseWrite(res, { type: "done", step_count: info.stepCount, usage: info.usage, session_id: saved });
+                            if (!res.writableEnded)
+                                res.end();
+                        },
+                    };
+                    await runOnce(messages, instructions, modelId, abort.signal, callbacks);
+                }
+                else {
+                    await runOnce(messages, instructions, modelId, abort.signal);
+                    const lastAssistant = [...messages].reverse().find((m) => m.role === "assistant");
+                    let saved;
+                    if (sessionId) {
+                        try {
+                            saved = saveSession(messages, sessionId);
+                        }
+                        catch { }
+                    }
+                    sendJson(res, 200, { messages, assistant: lastAssistant ?? null, session_id: saved });
+                }
+                return;
+            }
+            // ─── MCP management (continued) ───────────────────────────────────
+            if (req.method === "POST" && pathname === "/v1/mcp") {
+                const raw = await readBody(req);
+                const body = JSON.parse(raw);
+                if (!body.name) {
+                    sendJson(res, 400, { error: "missing_name" });
+                    return;
+                }
+                const { loadMcpConfig, saveMcpConfig } = await import("./mcp.js");
+                const config = loadMcpConfig();
+                if (body.url) {
+                    config.mcpServers[body.name] = { url: body.url, token: body.token, enabled: body.enabled !== false };
+                }
+                else if (body.command && body.command.length > 0) {
+                    config.mcpServers[body.name] = { command: body.command, enabled: body.enabled !== false };
+                }
+                else {
+                    sendJson(res, 400, { error: "provide command[] or url" });
+                    return;
+                }
+                saveMcpConfig(config);
+                sendJson(res, 201, { ok: true, name: body.name });
+                return;
+            }
+            if (req.method === "DELETE" && pathname.startsWith("/v1/mcp/")) {
+                const name = decodeURIComponent(pathname.slice("/v1/mcp/".length));
+                if (!name) {
+                    sendJson(res, 400, { error: "missing_name" });
+                    return;
+                }
+                const { loadMcpConfig, saveMcpConfig } = await import("./mcp.js");
+                const config = loadMcpConfig();
+                if (!config.mcpServers[name]) {
+                    sendJson(res, 404, { error: "mcp_not_found", name });
+                    return;
+                }
+                delete config.mcpServers[name];
+                saveMcpConfig(config);
+                sendJson(res, 200, { ok: true, deleted: name });
+                return;
+            }
+            // ─── Context / Compact ─────────────────────────────────────────────
+            if (req.method === "GET" && pathname === "/v1/context") {
+                const config = loadConfig();
+                const ctxWindow = await getContextWindow(config.provider?.defaultModel);
+                sendJson(res, 200, {
+                    context_window: ctxWindow,
+                    model: config.provider?.defaultModel ?? null,
+                });
+                return;
+            }
+            if (req.method === "POST" && pathname === "/v1/chat/compact") {
+                const raw = await readBody(req);
+                const body = JSON.parse(raw);
+                if (!body.session_id) {
+                    sendJson(res, 400, { error: "missing_session_id" });
+                    return;
+                }
+                const session = loadSession(body.session_id);
+                if (!session) {
+                    sendJson(res, 404, { error: "session_not_found" });
+                    return;
+                }
+                const model = resolveModel();
+                const result = await compactMessages(session.messages, model, { autoContinue: false });
+                if (result.compacted) {
+                    saveSession(result.messages, body.session_id);
+                }
+                sendJson(res, 200, { ok: true, compacted: result.compacted, message_count: result.messages.length });
+                return;
+            }
             sendJson(res, 404, { error: "not_found", path: pathname });
         }
         catch (err) {

package/dist/sessions.js

@@ -1,6 +1,7 @@
-import { readFileSync, writeFileSync, mkdirSync, existsSync, readdirSync } from "fs";
+import { readFileSync, writeFileSync, mkdirSync, existsSync, readdirSync, unlinkSync } from "fs";
 import path from "path";
 import { getConfigDir } from "./config.js";
+import { generateTitle } from "./title-gen.js";
 function getSessionsDir() {
     return path.join(getConfigDir(), "sessions");
 }
@@ -17,7 +18,7 @@ function deriveTitle(messages) {
     const content = typeof first.content === "string" ? first.content : "";
     return content.slice(0, 60) || "Untitled";
 }
-export function saveSession(messages, existingId) {
+export function saveSession(messages, existingId, title) {
     const dir = getSessionsDir();
     mkdirSync(dir, { recursive: true });
     const id = existingId ?? generateId();
@@ -25,7 +26,7 @@ export function saveSession(messages, existingId) {
     const data = {
         meta: {
             id,
-            title: deriveTitle(messages),
+            title: title ?? deriveTitle(messages),
             created: existingId ? loadSession(id)?.meta.created ?? now : now,
             updated: now,
             messageCount: messages.length,
@@ -35,6 +36,15 @@ export function saveSession(messages, existingId) {
     writeFileSync(sessionPath(id), JSON.stringify(data, null, 2), "utf-8");
     return id;
 }
+/** Save session with auto-generated title from LLM */
+export async function saveSessionWithTitle(messages, model, existingId) {
+    let title = null;
+    try {
+        title = await generateTitle(model, messages);
+    }
+    catch { }
+    return saveSession(messages, existingId, title ?? undefined);
+}
 export function loadSession(id) {
     const file = sessionPath(id);
     if (!existsSync(file))
@@ -68,7 +78,6 @@ export function deleteSession(id) {
     const file = sessionPath(id);
     if (!existsSync(file))
         return false;
-    const { unlinkSync } = require("fs");
     unlinkSync(file);
     return true;
 }