min-agent 0.2.1 → 0.4.0

package/dist/serve/routes-chat.js

@@ -0,0 +1,347 @@
+import { loadInstructions } from "../instructions.js";
+import { loadSession, saveSession, withSessionLock } from "../sessions.js";
+import { buildUserContent } from "../agent.js";
+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";
+/** 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") {
+        sendJson(res, 415, { error: "unsupported_media_type", detail: "Use Content-Type: application/json" });
+        return;
+    }
+    if (ctx.activeChats >= MAX_CONCURRENT_CHATS) {
+        sendJson(res, 429, {
+            error: "too_many_concurrent_requests",
+            detail: `Max ${MAX_CONCURRENT_CHATS} concurrent chats`,
+        });
+        return;
+    }
+    ctx.activeChats++;
+    try {
+        const parsed = await readJsonBody(req);
+        if (!parsed.ok) {
+            sendJsonError(res, parsed);
+            return;
+        }
+        const body = parsed.value;
+        const sandboxParsed = readSandboxTighten(body);
+        if (!sandboxParsed.ok) {
+            sendJson(res, 400, { error: sandboxParsed.error, detail: sandboxParsed.detail });
+            return;
+        }
+        const sandboxTighten = sandboxParsed.policy;
+        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;
+        let messages;
+        if (sessionId) {
+            await withSessionLock(sessionId, async () => {
+                const session = loadSession(sessionId);
+                if (!session) {
+                    sendJson(res, 404, { error: "session_not_found", session_id: sessionId });
+                    return;
+                }
+                if (typeof body.message !== "string" || !body.message.trim()) {
+                    sendJson(res, 400, {
+                        error: "session_requires_message",
+                        detail: "With `session_id`, send a non-empty `message` for the new user turn",
+                    });
+                    return;
+                }
+                const messages = [...session.messages];
+                const content = body.images && body.images.length > 0 ? await buildUserContent(body.message, body.images) : body.message;
+                messages.push({ role: "user", content });
+                await executeChat(ctx, {
+                    res,
+                    messages,
+                    modelId,
+                    stream,
+                    sessionId,
+                    runOptions: chatRunOptions(body),
+                    autoApprove: body.auto_approve !== false,
+                    taskState: session.taskState ?? emptyTaskState(),
+                    sandboxTighten,
+                });
+            });
+            return;
+        }
+        else {
+            const norm = normalizeMessages(body);
+            if (!norm.ok) {
+                sendJson(res, 400, { error: "invalid_body", detail: norm.error });
+                return;
+            }
+            messages = norm.messages;
+            if (body.images && body.images.length > 0) {
+                const last = messages[messages.length - 1];
+                if (!last || last.role !== "user" || typeof body.message !== "string") {
+                    sendJson(res, 400, {
+                        error: "images_require_message",
+                        detail: "With `images`, send a top-level `message` string for the user turn",
+                    });
+                    return;
+                }
+                messages[messages.length - 1] = {
+                    role: "user",
+                    content: await buildUserContent(body.message, body.images),
+                };
+            }
+        }
+        await executeChat(ctx, {
+            res,
+            messages,
+            modelId,
+            stream,
+            sessionId,
+            runOptions: chatRunOptions(body),
+            autoApprove: body.auto_approve !== false,
+            sandboxTighten,
+        });
+    }
+    finally {
+        ctx.activeChats--;
+    }
+}
+export const handleChatRoutes = async (req, res, ctx, _url, pathname) => {
+    if (req.method === "POST" && pathname === "/v1/chat/reload-instructions") {
+        ctx.instructions = await loadInstructions();
+        sendJson(res, 200, { ok: true, instructions_chars: ctx.instructions.join("\n").length });
+        return true;
+    }
+    if (req.method === "POST" && (pathname === "/v1/chat" || pathname === "/v1/code")) {
+        await handleChatRequest(ctx, req, res);
+        return true;
+    }
+    if (req.method === "POST" && pathname === "/v1/chat/redo") {
+        const parsed = await readJsonBody(req);
+        if (!parsed.ok) {
+            sendJsonError(res, parsed);
+            return true;
+        }
+        const body = parsed.value;
+        const sessionId = typeof body.session_id === "string" ? body.session_id : undefined;
+        if (!sessionId) {
+            sendJson(res, 400, { error: "missing_session_id" });
+            return true;
+        }
+        const sandboxParsed = readSandboxTighten(body);
+        if (!sandboxParsed.ok) {
+            sendJson(res, 400, { error: sandboxParsed.error, detail: sandboxParsed.detail });
+            return true;
+        }
+        if (ctx.activeChats >= MAX_CONCURRENT_CHATS) {
+            sendJson(res, 429, {
+                error: "too_many_concurrent_requests",
+                detail: `Max ${MAX_CONCURRENT_CHATS} concurrent chats`,
+            });
+            return true;
+        }
+        ctx.activeChats++;
+        try {
+            await withSessionLock(sessionId, async () => {
+                const session = loadSession(sessionId);
+                if (!session) {
+                    sendJson(res, 404, { error: "session_not_found", session_id: sessionId });
+                    return;
+                }
+                const text = lastUserText(session.messages);
+                if (!text) {
+                    sendJson(res, 400, { error: "no_user_message" });
+                    return;
+                }
+                await executeChat(ctx, {
+                    res,
+                    messages: [...session.messages, { role: "user", content: text }],
+                    modelId: typeof body.model === "string" ? body.model : undefined,
+                    stream: body.stream === true,
+                    sessionId,
+                    runOptions: chatRunOptions(body),
+                    autoApprove: body.auto_approve !== false,
+                    taskState: session.taskState ?? emptyTaskState(),
+                    sandboxTighten: sandboxParsed.policy,
+                });
+            });
+        }
+        finally {
+            ctx.activeChats--;
+        }
+        return true;
+    }
+    if (req.method === "POST" && pathname === "/v1/approvals") {
+        const parsed = await readJsonBody(req);
+        if (!parsed.ok) {
+            sendJsonError(res, parsed);
+            return true;
+        }
+        const id = parsed.value.id?.trim();
+        if (!id) {
+            sendJson(res, 400, { error: "missing_id" });
+            return true;
+        }
+        if (typeof parsed.value.accepted !== "boolean") {
+            sendJson(res, 400, { error: "missing_accepted" });
+            return true;
+        }
+        if (!ctx.approvalGate.resolveConfirm(id, parsed.value.accepted)) {
+            sendJson(res, 404, { error: "unknown_approval_id", id });
+            return true;
+        }
+        sendJson(res, 200, { ok: true, id, accepted: parsed.value.accepted });
+        return true;
+    }
+    if (req.method === "POST" && pathname === "/v1/answers") {
+        const parsed = await readJsonBody(req);
+        if (!parsed.ok) {
+            sendJsonError(res, parsed);
+            return true;
+        }
+        const id = parsed.value.id?.trim();
+        if (!id) {
+            sendJson(res, 400, { error: "missing_id" });
+            return true;
+        }
+        const answer = parsed.value.answer === undefined ? null : parsed.value.answer;
+        if (answer !== null && typeof answer !== "string") {
+            sendJson(res, 400, { error: "invalid_answer" });
+            return true;
+        }
+        if (!ctx.approvalGate.resolveQuestion(id, answer)) {
+            sendJson(res, 404, { error: "unknown_answer_id", id });
+            return true;
+        }
+        sendJson(res, 200, { ok: true, id });
+        return true;
+    }
+    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 true;
+        }
+        if (ctx.activeChats >= MAX_CONCURRENT_CHATS) {
+            sendJson(res, 429, {
+                error: "too_many_concurrent_requests",
+                detail: `Max ${MAX_CONCURRENT_CHATS} concurrent chats`,
+            });
+            return true;
+        }
+        const parsed = await readJsonBody(req);
+        if (!parsed.ok) {
+            sendJsonError(res, parsed);
+            return true;
+        }
+        const body = parsed.value;
+        if (!body.image_base64) {
+            sendJson(res, 400, { error: "missing_image_base64" });
+            return true;
+        }
+        const sandboxParsed = readSandboxTighten(body);
+        if (!sandboxParsed.ok) {
+            sendJson(res, 400, { error: sandboxParsed.error, detail: sandboxParsed.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?";
+        const modelId = body.model;
+        const sessionId = body.session_id;
+        const stream = body.stream === true;
+        ctx.activeChats++;
+        try {
+            await withSessionLock(sessionId, async () => {
+                let messages = [];
+                let pasteTaskState;
+                if (sessionId) {
+                    const session = loadSession(sessionId);
+                    if (!session) {
+                        sendJson(res, 404, { error: "session_not_found", session_id: sessionId });
+                        return;
+                    }
+                    messages = [...session.messages];
+                    pasteTaskState = session.taskState;
+                }
+                messages.push({
+                    role: "user",
+                    content: [
+                        { type: "text", text },
+                        { type: "image", image: imageBuffer, mimeType },
+                    ],
+                });
+                await executeChat(ctx, {
+                    res,
+                    messages,
+                    modelId,
+                    stream,
+                    sessionId,
+                    runOptions: chatRunOptions(body),
+                    autoApprove: body.auto_approve !== false,
+                    taskState: pasteTaskState ?? emptyTaskState(),
+                    sandboxTighten: sandboxParsed.policy,
+                });
+            });
+        }
+        finally {
+            ctx.activeChats--;
+        }
+        return true;
+    }
+    if (req.method === "POST" && pathname === "/v1/chat/compact") {
+        const parsed = await readJsonBody(req);
+        if (!parsed.ok) {
+            sendJsonError(res, parsed);
+            return true;
+        }
+        const body = parsed.value;
+        if (!body.session_id) {
+            sendJson(res, 400, { error: "missing_session_id" });
+            return true;
+        }
+        const session = loadSession(body.session_id);
+        if (!session) {
+            sendJson(res, 404, { error: "session_not_found" });
+            return true;
+        }
+        const model = resolveModel();
+        const result = await compactMessages(session.messages, model, { taskGoal: session.taskState?.goal });
+        if (result.compacted) {
+            saveSession(result.messages, body.session_id);
+        }
+        sendJson(res, 200, { ok: true, compacted: result.compacted, message_count: result.messages.length });
+        return true;
+    }
+    if (req.method === "POST" && pathname === "/v1/chat/undo") {
+        const parsed = await readJsonBody(req);
+        if (!parsed.ok) {
+            sendJsonError(res, parsed);
+            return true;
+        }
+        const body = parsed.value;
+        if (!body.session_id) {
+            sendJson(res, 400, { error: "missing_session_id" });
+            return true;
+        }
+        const session = loadSession(body.session_id);
+        if (!session) {
+            sendJson(res, 404, { error: "session_not_found" });
+            return true;
+        }
+        let userIdx = -1;
+        for (let i = session.messages.length - 1; i >= 0; i--) {
+            if (session.messages[i].role === "user") {
+                userIdx = i;
+                break;
+            }
+        }
+        if (userIdx === -1) {
+            sendJson(res, 400, { error: "no_user_message" });
+            return true;
+        }
+        session.messages = session.messages.slice(0, userIdx + 1);
+        saveSession(session.messages, body.session_id);
+        sendJson(res, 200, { ok: true, message_count: session.messages.length, messages: session.messages });
+        return true;
+    }
+    return false;
+};

package/dist/serve/routes-mcp.js

@@ -0,0 +1,212 @@
+import { getMcpStatus, syncMcpConnections, loadMcpConfigEntries, listMcpCatalog, readMcpResource, getMcpPrompt, } from "../mcp.js";
+import { sendJson, sendJsonError, readJsonBody, decodePathSegment } from "./common.js";
+export const handleMcpRoutes = async (req, res, _ctx, url, pathname) => {
+    if (req.method === "GET" && pathname === "/v1/mcp") {
+        const status = getMcpStatus();
+        sendJson(res, 200, { servers: status });
+        return true;
+    }
+    const mcpResources = pathname.match(/^\/v1\/mcp\/([^/]+)\/resources$/);
+    if (req.method === "GET" && mcpResources) {
+        const name = decodePathSegment(mcpResources[1]);
+        if (!name) {
+            sendJson(res, 400, { error: "missing_name" });
+            return true;
+        }
+        const status = getMcpStatus()[name];
+        if (!status) {
+            sendJson(res, 404, { error: "mcp_not_found", name });
+            return true;
+        }
+        if (!status.connected) {
+            sendJson(res, 404, { error: "mcp_not_connected", name });
+            return true;
+        }
+        const catalog = listMcpCatalog(name).servers[0];
+        sendJson(res, 200, { name, resources: catalog.resources, templates: catalog.templates });
+        return true;
+    }
+    const mcpPrompts = pathname.match(/^\/v1\/mcp\/([^/]+)\/prompts$/);
+    if (req.method === "GET" && mcpPrompts) {
+        const name = decodePathSegment(mcpPrompts[1]);
+        if (!name) {
+            sendJson(res, 400, { error: "missing_name" });
+            return true;
+        }
+        const status = getMcpStatus()[name];
+        if (!status) {
+            sendJson(res, 404, { error: "mcp_not_found", name });
+            return true;
+        }
+        if (!status.connected) {
+            sendJson(res, 404, { error: "mcp_not_connected", name });
+            return true;
+        }
+        const catalog = listMcpCatalog(name).servers[0];
+        sendJson(res, 200, { name, prompts: catalog.prompts });
+        return true;
+    }
+    const mcpRead = pathname.match(/^\/v1\/mcp\/([^/]+)\/resources\/read$/);
+    if (req.method === "POST" && mcpRead) {
+        const name = decodePathSegment(mcpRead[1]);
+        if (!name) {
+            sendJson(res, 400, { error: "missing_name" });
+            return true;
+        }
+        const parsed = await readJsonBody(req);
+        if (!parsed.ok) {
+            sendJsonError(res, parsed);
+            return true;
+        }
+        const uri = parsed.value.uri?.trim();
+        if (!uri) {
+            sendJson(res, 400, { error: "missing_uri" });
+            return true;
+        }
+        const status = getMcpStatus()[name];
+        if (!status) {
+            sendJson(res, 404, { error: "mcp_not_found", name });
+            return true;
+        }
+        if (!status.connected) {
+            sendJson(res, 404, { error: "mcp_not_connected", name });
+            return true;
+        }
+        const content = await readMcpResource(uri, name);
+        sendJson(res, 200, { ok: true, name, uri, content });
+        return true;
+    }
+    const mcpGetPrompt = pathname.match(/^\/v1\/mcp\/([^/]+)\/prompts\/get$/);
+    if (req.method === "POST" && mcpGetPrompt) {
+        const name = decodePathSegment(mcpGetPrompt[1]);
+        if (!name) {
+            sendJson(res, 400, { error: "missing_name" });
+            return true;
+        }
+        const parsed = await readJsonBody(req);
+        if (!parsed.ok) {
+            sendJsonError(res, parsed);
+            return true;
+        }
+        const prompt = parsed.value.prompt?.trim();
+        if (!prompt) {
+            sendJson(res, 400, { error: "missing_prompt" });
+            return true;
+        }
+        const status = getMcpStatus()[name];
+        if (!status) {
+            sendJson(res, 404, { error: "mcp_not_found", name });
+            return true;
+        }
+        if (!status.connected) {
+            sendJson(res, 404, { error: "mcp_not_connected", name });
+            return true;
+        }
+        const content = await getMcpPrompt(prompt, parsed.value.arguments, name);
+        sendJson(res, 200, { ok: true, name, prompt, content });
+        return true;
+    }
+    if (req.method === "POST" && pathname === "/v1/mcp") {
+        const parsed = await readJsonBody(req);
+        if (!parsed.ok) {
+            sendJsonError(res, parsed);
+            return true;
+        }
+        const body = parsed.value;
+        if (!body.name) {
+            sendJson(res, 400, { error: "missing_name" });
+            return true;
+        }
+        if (body.remoteTransport && !["streamable-http", "sse", "auto"].includes(body.remoteTransport)) {
+            sendJson(res, 400, { error: "invalid_remote_transport", allowed: ["streamable-http", "sse", "auto"] });
+            return true;
+        }
+        const scope = body.project ? "project" : "global";
+        const { loadMcpConfigFile, saveMcpConfig } = await import("../mcp.js");
+        const config = loadMcpConfigFile(scope);
+        const common = {
+            ...(body.environment ? { environment: body.environment } : {}),
+            ...(body.headers ? { headers: body.headers } : {}),
+            ...(body.remoteTransport ? { remoteTransport: body.remoteTransport } : {}),
+            ...(body.timeout !== undefined ? { timeout: body.timeout } : {}),
+            ...(body.connectTimeout !== undefined ? { connectTimeout: body.connectTimeout } : {}),
+            ...(body.callTimeout !== undefined ? { callTimeout: body.callTimeout } : {}),
+            enabled: body.enabled !== false,
+        };
+        if (body.url) {
+            config.mcpServers[body.name] = { url: body.url, ...(body.token ? { token: body.token } : {}), ...common };
+        }
+        else if (typeof body.command === "string" && body.command.length > 0) {
+            config.mcpServers[body.name] = { command: body.command, ...(body.args ? { args: body.args } : {}), ...common };
+        }
+        else if (Array.isArray(body.command) && body.command.length > 0) {
+            config.mcpServers[body.name] = { command: body.command, ...common };
+        }
+        else {
+            sendJson(res, 400, { error: "provide command or url" });
+            return true;
+        }
+        saveMcpConfig(config, scope);
+        await syncMcpConnections();
+        const status = getMcpStatus()[body.name];
+        sendJson(res, 201, {
+            ok: true,
+            name: body.name,
+            scope,
+            connected: status?.connected ?? false,
+            ...(status?.error ? { error: status.error } : {}),
+            ...(status?.tools?.length ? { tools: status.tools } : {}),
+        });
+        return true;
+    }
+    if (req.method === "DELETE" && pathname.startsWith("/v1/mcp/")) {
+        const name = decodePathSegment(pathname.slice("/v1/mcp/".length));
+        if (!name) {
+            sendJson(res, 400, { error: "missing_name" });
+            return true;
+        }
+        const scope = url.searchParams.get("project") === "1" ? "project" : "global";
+        const { loadMcpConfigFile, saveMcpConfig } = await import("../mcp.js");
+        const config = loadMcpConfigFile(scope);
+        if (!config.mcpServers[name]) {
+            sendJson(res, 404, { error: "mcp_not_found", name, scope, available: Object.keys(config.mcpServers) });
+            return true;
+        }
+        delete config.mcpServers[name];
+        saveMcpConfig(config, scope);
+        await syncMcpConnections();
+        sendJson(res, 200, { ok: true, deleted: name, scope });
+        return true;
+    }
+    const mcpToggle = pathname.match(/^\/v1\/mcp\/([^/]+)\/(enable|disable)$/);
+    if (req.method === "POST" && mcpToggle) {
+        const name = decodePathSegment(mcpToggle[1]);
+        if (!name) {
+            sendJson(res, 400, { error: "missing_name" });
+            return true;
+        }
+        const enabled = mcpToggle[2] === "enable";
+        const parsed = await readJsonBody(req);
+        const scope = parsed.ok && parsed.value.scope === "project" ? "project" : "global";
+        const { loadMcpConfigFile, saveMcpConfig } = await import("../mcp.js");
+        const config = loadMcpConfigFile(scope);
+        if (!config.mcpServers[name]) {
+            const known = loadMcpConfigEntries().some((e) => e.name === name);
+            sendJson(res, 404, {
+                error: "mcp_not_found",
+                name,
+                scope,
+                ...(known
+                    ? { hint: `server exists in another scope; pass the matching scope` }
+                    : { available: Object.keys(config.mcpServers) }),
+            });
+            return true;
+        }
+        config.mcpServers[name].enabled = enabled;
+        saveMcpConfig(config, scope);
+        await syncMcpConnections();
+        sendJson(res, 200, { ok: true, name, enabled, scope, connected: getMcpStatus()[name]?.connected ?? false });
+        return true;
+    }
+    return false;
+};

package/dist/serve/routes-memory.js

@@ -0,0 +1,66 @@
+import { loadMemories, addMemory, deleteMemory, searchMemories, readMemoryScope } 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") {
+        sendJson(res, 200, { memories: loadMemories("global"), project_memories: loadMemories("project") });
+        return true;
+    }
+    if (req.method === "POST" && pathname === "/v1/memory") {
+        const parsed = await readJsonBody(req);
+        if (!parsed.ok) {
+            sendJsonError(res, parsed);
+            return true;
+        }
+        const body = parsed.value;
+        if (!body.content) {
+            sendJson(res, 400, { error: "missing_content" });
+            return true;
+        }
+        const scopeParsed = readMemoryScope(body.scope);
+        if (!scopeParsed.ok) {
+            sendJson(res, 400, { error: "invalid_scope", allowed: ["global", "project"] });
+            return true;
+        }
+        const scope = scopeParsed.scope ?? "global";
+        const memory = addMemory(body.content, body.tags ?? [], scope);
+        sendJson(res, 201, { ok: true, memory, scope });
+        return true;
+    }
+    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 true;
+        }
+        const scopeParsed = readMemoryScope(url.searchParams.get("scope"));
+        if (!scopeParsed.ok) {
+            sendJson(res, 400, { error: "invalid_scope", allowed: ["global", "project"] });
+            return true;
+        }
+        const globalResults = scopeParsed.scope === "project" ? [] : searchMemories(query, "global");
+        const projectResults = scopeParsed.scope === "global" ? [] : searchMemories(query, "project");
+        sendJson(res, 200, { results: globalResults, project_results: projectResults });
+        return true;
+    }
+    if (req.method === "DELETE" && pathname.startsWith("/v1/memory/")) {
+        const idx = parseInt(pathname.slice("/v1/memory/".length), 10);
+        if (Number.isNaN(idx)) {
+            sendJson(res, 400, { error: "invalid_index" });
+            return true;
+        }
+        const scopeParsed = readMemoryScope(url.searchParams.get("scope"));
+        if (!scopeParsed.ok) {
+            sendJson(res, 400, { error: "invalid_scope", allowed: ["global", "project"] });
+            return true;
+        }
+        const scope = scopeParsed.scope ?? "global";
+        const ok = deleteMemory(idx - 1, scope);
+        if (!ok) {
+            sendJson(res, 404, { error: "memory_not_found", index: idx, scope });
+            return true;
+        }
+        sendJson(res, 200, { ok: true, deleted: idx, scope });
+        return true;
+    }
+    return false;
+};