min-agent 0.5.1 → 0.6.0

package/dist/serve/common.js

@@ -1,425 +0,0 @@
-import { randomUUID } from "crypto";
-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";
-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 { 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)
-            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,
-        thinking: parseThinkingEffort(body.thinking),
-        memory: parseMemoryMode(body.memory),
-        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,
-    });
-}