min-agent 0.2.1 → 0.4.0

package/dist/serve/common.js

@@ -0,0 +1,404 @@
+import { randomUUID } from "crypto";
+import { getSandboxSnapshot, getPermissionSnapshot, permissionModeLabel } from "../config.js";
+import { parseNetworkPolicy, parseSandboxMode, runWithSandboxPolicy } from "../sandbox.js";
+import { runWithConfirmContext, getPermissionOverride } from "../confirm.js";
+import { runOnceWithSystem } from "../agent.js";
+import { saveSession, sanitizeForStorage } from "../sessions.js";
+import { createSaveThrottle } from "../save-throttle.js";
+import { scanProject, buildCodeSystemPrompt } from "../code-mode.js";
+import { TokenTracker } from "../compaction.js";
+import { emptyTaskState } from "../tools/todo.js";
+export { localVersion as packageVersion } from "../updater.js";
+const MAX_BODY_BYTES = 2 * 1024 * 1024;
+const BODY_TIMEOUT_MS = 30_000;
+const MAX_TOOL_RESULT_SSE_CHARS = 48_000;
+export const MAX_CONCURRENT_CHATS = 8;
+export function corsEnabled() {
+    const v = process.env.MIN_AGENT_SERVE_CORS;
+    return v === "1" || v === "true";
+}
+export function corsHeaders() {
+    if (corsEnabled()) {
+        return {
+            "Access-Control-Allow-Origin": "*",
+            "Access-Control-Allow-Methods": "GET, POST, DELETE, OPTIONS",
+            "Access-Control-Allow-Headers": "Content-Type, Authorization",
+        };
+    }
+    return {};
+}
+export function skillPayload(s) {
+    return {
+        name: s.name,
+        description: s.description,
+        location: s.location,
+        enabled: s.enabled,
+        ...(s.disabledScope ? { disabled_scope: s.disabledScope } : {}),
+        ...(s.version ? { version: s.version } : {}),
+        ...(s.allowedTools.length ? { allowed_tools: s.allowedTools } : {}),
+        ...(s.requiredBins.length ? { requires_bins: s.requiredBins } : {}),
+        ...(s.builtin ? { builtin: true } : {}),
+        ...(s.alwaysLoad ? { always_load: true } : {}),
+    };
+}
+export function sendJson(res, status, body) {
+    const headers = {
+        "Content-Type": "application/json; charset=utf-8",
+        ...corsHeaders(),
+    };
+    res.writeHead(status, headers);
+    res.end(JSON.stringify(body));
+}
+/** Decode a URL path segment without letting malformed escapes become a 500. */
+export function decodePathSegment(raw) {
+    try {
+        return decodeURIComponent(raw);
+    }
+    catch {
+        return null;
+    }
+}
+function readBody(req) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        let total = 0;
+        const timer = setTimeout(() => {
+            req.destroy();
+            reject(new Error("body_timeout"));
+        }, BODY_TIMEOUT_MS);
+        req.on("data", (c) => {
+            total += c.length;
+            if (total > MAX_BODY_BYTES) {
+                clearTimeout(timer);
+                req.removeAllListeners("data");
+                req.pause();
+                reject(new Error("body_too_large"));
+                return;
+            }
+            chunks.push(c);
+        });
+        req.on("end", () => {
+            clearTimeout(timer);
+            resolve(Buffer.concat(chunks).toString("utf-8"));
+        });
+        req.on("error", (e) => {
+            clearTimeout(timer);
+            reject(e);
+        });
+    });
+}
+export async function readJsonBody(req) {
+    let raw;
+    try {
+        raw = await readBody(req);
+    }
+    catch (e) {
+        if (e?.message === "body_too_large") {
+            return { ok: false, status: 413, error: "payload_too_large" };
+        }
+        if (e?.message === "body_timeout") {
+            return { ok: false, status: 408, error: "payload_timeout" };
+        }
+        throw e;
+    }
+    try {
+        return { ok: true, value: JSON.parse(raw) };
+    }
+    catch {
+        return { ok: false, status: 400, error: "invalid_json" };
+    }
+}
+export function sendJsonError(res, e) {
+    if (e.status === 413) {
+        // The request body was abandoned mid-stream; drop keep-alive so the
+        // connection cannot be reused for a second request.
+        res.shouldKeepAlive = false;
+    }
+    sendJson(res, e.status, e.status === 413 ? { error: e.error, max_bytes: MAX_BODY_BYTES } : { error: e.error });
+}
+function sseWrite(res, obj) {
+    try {
+        if (res.writableEnded)
+            return;
+        res.write(`data: ${JSON.stringify(obj)}\n\n`);
+    }
+    catch {
+        /* client gone */
+    }
+}
+function truncateForJson(v, max) {
+    if (typeof v === "string" && v.length > max)
+        return v.slice(0, max) + `\n… [truncated ${v.length - max} chars]`;
+    return v;
+}
+function sseHeaders(cors) {
+    return {
+        "Content-Type": "text/event-stream; charset=utf-8",
+        "Cache-Control": "no-cache, no-transform",
+        Connection: "keep-alive",
+        "X-Accel-Buffering": "no",
+        ...cors,
+    };
+}
+function createSseCallbacks(res, messages, opts = {}) {
+    return {
+        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: truncateForJson(input, MAX_TOOL_RESULT_SSE_CHARS) });
+        },
+        onToolResult(name, output) {
+            sseWrite(res, { type: "tool_result", name, output: truncateForJson(output, MAX_TOOL_RESULT_SSE_CHARS) });
+        },
+        onCompaction(line) {
+            sseWrite(res, { type: "compaction", line });
+        },
+        onRetryNotice(info) {
+            sseWrite(res, {
+                type: "notice",
+                kind: info.kind,
+                attempt: info.attempt,
+                max_attempts: info.maxAttempts,
+                delay_ms: info.delayMs,
+            });
+        },
+        onStreamError(message) {
+            sseWrite(res, { type: "error", message });
+        },
+        onRunFinish(info) {
+            let saved;
+            if (opts.sessionId && messages.length > 0) {
+                try {
+                    saved = saveSession(messages, opts.sessionId, undefined, undefined, opts.taskState);
+                }
+                catch {
+                    saved = undefined;
+                }
+            }
+            sseWrite(res, {
+                type: "done",
+                step_count: info.stepCount,
+                usage: info.usage,
+                context_tokens: info.contextTokens ?? 0,
+                has_error: info.hasError,
+                aborted: info.aborted,
+                max_steps_reached: info.maxStepsReached,
+                incomplete: info.incomplete ?? false,
+                budget_exceeded: info.budgetExceeded ?? false,
+                continues: info.continues ?? 0,
+                stopped: info.stopped ?? false,
+                empty_response: info.emptyResponse ?? false,
+                empty_attempts: info.emptyAttempts ?? 0,
+                wrap_up: info.wrapUp ?? false,
+                session_id: saved,
+                messages: sanitizeForStorage(messages),
+                task_state: opts.taskState,
+                project: opts.project,
+            });
+            if (!res.writableEnded)
+                res.end();
+        },
+    };
+}
+function createJsonCallbacks() {
+    const toolCalls = [];
+    const toolResults = [];
+    let finishInfo = null;
+    const callbacks = {
+        onToolCall(name, input) {
+            toolCalls.push({ name, input: truncateForJson(input, MAX_TOOL_RESULT_SSE_CHARS) });
+        },
+        onToolResult(name, output) {
+            toolResults.push({ name, output: truncateForJson(output, MAX_TOOL_RESULT_SSE_CHARS) });
+        },
+        onRunFinish(info) {
+            finishInfo = info;
+        },
+    };
+    return { callbacks, toolCalls, toolResults, finishInfo: () => finishInfo };
+}
+export function readSandboxTighten(body) {
+    const policy = {};
+    if (body.sandbox !== undefined) {
+        const mode = parseSandboxMode(body.sandbox);
+        if (!mode)
+            return { ok: false, error: "invalid_sandbox", detail: "sandbox must be off, workspace, or strict" };
+        policy.mode = mode;
+    }
+    if (body.network !== undefined) {
+        const network = parseNetworkPolicy(body.network);
+        if (!network)
+            return { ok: false, error: "invalid_network", detail: "network must be allow or deny" };
+        policy.network = network;
+    }
+    return { ok: true, policy };
+}
+export function readStringPathList(value) {
+    if (value === undefined)
+        return { ok: true };
+    if (!Array.isArray(value) || value.some((p) => typeof p !== "string" || p.length === 0))
+        return { ok: false };
+    return { ok: true, value };
+}
+export function sandboxPayload() {
+    const snap = getSandboxSnapshot();
+    return {
+        mode: snap.mode,
+        network: snap.network,
+        extraWriteRoots: snap.extraWriteRoots,
+        extraReadRoots: snap.extraReadRoots,
+        source: snap.source,
+        label: snap.label,
+    };
+}
+export function permissionPayload() {
+    const override = getPermissionOverride();
+    const snap = getPermissionSnapshot();
+    const permission = override ?? snap.permission;
+    const source = override ? "cli" : snap.source;
+    return {
+        permission,
+        source,
+        label: permissionModeLabel(permission),
+    };
+}
+export function normalizeMessages(body) {
+    if (body.messages && Array.isArray(body.messages)) {
+        if (body.messages.length === 0)
+            return { ok: false, error: "messages must be non-empty" };
+        return { ok: true, messages: [...body.messages] };
+    }
+    if (typeof body.message === "string" && body.message.length > 0) {
+        return { ok: true, messages: [{ role: "user", content: body.message }] };
+    }
+    return { ok: false, error: "Provide `message` (string) or non-empty `messages` array" };
+}
+export function chatRunOptions(body) {
+    return {
+        temperature: typeof body.temperature === "number" ? body.temperature : undefined,
+        maxTokens: typeof body.maxTokens === "number" ? body.maxTokens : undefined,
+        topP: typeof body.topP === "number" ? body.topP : undefined,
+        providerName: typeof body.provider === "string" ? body.provider : undefined,
+        ...(body.plan_mode === true ? { planMode: true } : {}),
+    };
+}
+function httpConfirmContext(ctx, res, autoApprove, pendingIds) {
+    if (autoApprove)
+        return { autoApprove: true };
+    return {
+        autoApprove: false,
+        onConfirm: async (message) => {
+            const id = randomUUID();
+            pendingIds.push(id);
+            sseWrite(res, { type: "confirm", id, message });
+            return ctx.approvalGate.waitConfirm(id);
+        },
+        onQuestion: async (prompt, options) => {
+            const id = randomUUID();
+            pendingIds.push(id);
+            sseWrite(res, { type: "question", id, prompt, ...(options && options.length > 0 ? { options } : {}) });
+            return ctx.approvalGate.waitQuestion(id);
+        },
+    };
+}
+export async function executeChat(ctx, opts) {
+    const { res, messages, modelId, stream, sessionId, runOptions, autoApprove } = opts;
+    const taskState = opts.taskState ?? emptyTaskState();
+    if (!autoApprove && !stream) {
+        sendJson(res, 400, {
+            error: "auto_approve_requires_stream",
+            detail: "Set stream: true when auto_approve is false, then answer via POST /v1/approvals and POST /v1/answers",
+        });
+        return;
+    }
+    const abort = new AbortController();
+    const pendingIds = [];
+    const onClose = () => {
+        abort.abort();
+        for (const id of pendingIds)
+            ctx.approvalGate.cancel(id);
+    };
+    res.on("close", onClose);
+    const tracker = new TokenTracker();
+    const project = scanProject();
+    const codeSystemPrompt = buildCodeSystemPrompt(project, ctx.instructions);
+    const confirmCtx = httpConfirmContext(ctx, res, autoApprove, pendingIds);
+    const tighten = opts.sandboxTighten;
+    const run = (callbacks) => {
+        // Persist mid-run so a dropped connection or crash keeps the work so far.
+        const saveThrottle = sessionId != null
+            ? createSaveThrottle(() => {
+                try {
+                    saveSession(messages, sessionId, undefined, undefined, taskState);
+                }
+                catch { }
+            })
+            : null;
+        const exec = () => runWithConfirmContext(confirmCtx, () => runOnceWithSystem(messages, codeSystemPrompt, modelId, abort.signal, callbacks, tracker, {
+            ...runOptions,
+            taskState,
+            ...(saveThrottle ? { onStepPersist: () => saveThrottle.request() } : {}),
+        }));
+        const finish = (p) => p.finally(() => {
+            saveThrottle?.cancel();
+        });
+        if (tighten && (tighten.mode || tighten.network))
+            return finish(runWithSandboxPolicy(tighten, exec));
+        return finish(exec());
+    };
+    if (stream) {
+        res.writeHead(200, sseHeaders(corsHeaders()));
+        res.flushHeaders?.();
+        const callbacks = createSseCallbacks(res, messages, { sessionId, project, taskState });
+        try {
+            await run(callbacks);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            if (!res.writableEnded) {
+                sseWrite(res, { type: "fatal", message });
+                res.end();
+            }
+        }
+        return;
+    }
+    const { callbacks, toolCalls, toolResults, finishInfo } = createJsonCallbacks();
+    await run(callbacks);
+    const lastAssistant = [...messages].reverse().find((m) => m.role === "assistant");
+    let savedSession;
+    if (sessionId && messages.length > 0) {
+        try {
+            savedSession = saveSession(messages, sessionId, undefined, undefined, taskState);
+        }
+        catch {
+            savedSession = undefined;
+        }
+    }
+    const fi = finishInfo();
+    sendJson(res, 200, {
+        messages: sanitizeForStorage(messages),
+        assistant: lastAssistant ?? null,
+        tool_calls: toolCalls,
+        tool_results: toolResults,
+        session_id: savedSession,
+        step_count: fi?.stepCount ?? 0,
+        usage: fi?.usage ?? null,
+        context_tokens: fi?.contextTokens ?? 0,
+        has_error: fi?.hasError ?? false,
+        aborted: fi?.aborted ?? false,
+        max_steps_reached: fi?.maxStepsReached ?? false,
+        incomplete: fi?.incomplete ?? false,
+        budget_exceeded: fi?.budgetExceeded ?? false,
+        continues: fi?.continues ?? 0,
+        stopped: fi?.stopped ?? false,
+        empty_response: fi?.emptyResponse ?? false,
+        empty_attempts: fi?.emptyAttempts ?? 0,
+        wrap_up: fi?.wrapUp ?? false,
+        task_state: taskState,
+        project,
+    });
+}