min-agent 0.1.4 → 0.1.5

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;
 }

package/dist/structured-output.js

@@ -0,0 +1,29 @@
+import { tool, jsonSchema } from "ai";
+/**
+ * Structured output support.
+ *
+ * When the user requests JSON output matching a schema, a StructuredOutput tool
+ * is injected. The model MUST call this tool to return its final answer in the
+ * requested format.
+ *
+ * Based on opencode's structured output implementation in prompt.ts.
+ */
+const STRUCTURED_OUTPUT_DESCRIPTION = `Use this tool to return your final response in the requested structured format.
+
+IMPORTANT:
+- You MUST call this tool exactly once at the end of your response
+- The input must be valid JSON matching the required schema
+- Complete all necessary research and tool calls BEFORE calling this tool
+- This tool provides your final answer - no further actions are taken after calling it`;
+export const STRUCTURED_OUTPUT_SYSTEM = `IMPORTANT: The user has requested structured output. You MUST use the StructuredOutput tool to provide your final response. Do NOT respond with plain text - you MUST call the StructuredOutput tool with your answer formatted according to the schema.`;
+export function createStructuredOutputTool(request, onSuccess) {
+    const { $schema: _, ...toolSchema } = request.schema;
+    return tool({
+        description: STRUCTURED_OUTPUT_DESCRIPTION,
+        inputSchema: jsonSchema(toolSchema),
+        execute: async (args) => {
+            onSuccess(args);
+            return JSON.stringify(args, null, 2);
+        },
+    });
+}

package/dist/title-gen.js

@@ -0,0 +1,48 @@
+import { generateText } from "ai";
+/**
+ * Auto-generate a short title for a conversation session.
+ *
+ * Based on opencode's title agent — uses the LLM to produce a concise
+ * title from the first user message and assistant response.
+ */
+const TITLE_PROMPT = `Generate a very short title (max 50 chars) for this conversation. 
+Output ONLY the title text, nothing else. No quotes, no prefix.
+The title should capture the main topic or intent.`;
+export async function generateTitle(model, messages) {
+    // Need at least one user message
+    const userMsg = messages.find((m) => m.role === "user");
+    if (!userMsg)
+        return null;
+    const userContent = typeof userMsg.content === "string"
+        ? userMsg.content
+        : Array.isArray(userMsg.content)
+            ? userMsg.content.filter((p) => "text" in p).map((p) => p.text).join(" ")
+            : "";
+    if (!userContent.trim())
+        return null;
+    // Include first assistant response if available for better context
+    const assistantMsg = messages.find((m) => m.role === "assistant");
+    const assistantContent = assistantMsg
+        ? typeof assistantMsg.content === "string"
+            ? assistantMsg.content.slice(0, 200)
+            : ""
+        : "";
+    const context = assistantContent
+        ? `User: ${userContent.slice(0, 300)}\nAssistant: ${assistantContent}`
+        : `User: ${userContent.slice(0, 300)}`;
+    try {
+        const result = await generateText({
+            model,
+            messages: [
+                { role: "system", content: TITLE_PROMPT },
+                { role: "user", content: context },
+            ],
+            temperature: 0.5,
+        });
+        const title = result.text.trim().replace(/^["']|["']$/g, "").slice(0, 60);
+        return title || null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/tools/bash.js

@@ -1,72 +1,13 @@
-import { spawn } from "child_process";
 import { tool, jsonSchema } from "ai";
+import { spawn } from "child_process";
 import { confirm, isDangerousCommand, isAutoApprove } from "../confirm.js";
-import { truncateToolOutput } from "../tool-output.js";
-/** Hard cap for in-memory collection before killing the process (avoid OOM on huge stdout). */
-const COLLECT_HARD_CAP_BYTES = 16 * 1024 * 1024;
-function runCommand(command, cwd, timeoutMs) {
-    return new Promise((resolve, reject) => {
-        const child = spawn(command, {
-            shell: true,
-            cwd,
-            env: process.env,
-            stdio: ["ignore", "pipe", "pipe"],
-        });
-        const outChunks = [];
-        const errChunks = [];
-        let total = 0;
-        let killedCap = false;
-        let killedTimeout = false;
-        const timer = setTimeout(() => {
-            killedTimeout = true;
-            child.kill("SIGTERM");
-            setTimeout(() => child.kill("SIGKILL"), 2000).unref();
-        }, timeoutMs);
-        const push = (buf, arr) => {
-            total += buf.length;
-            if (total > COLLECT_HARD_CAP_BYTES && !killedCap) {
-                killedCap = true;
-                child.kill("SIGKILL");
-                return;
-            }
-            arr.push(buf);
-        };
-        child.stdout?.on("data", (b) => push(b, outChunks));
-        child.stderr?.on("data", (b) => push(b, errChunks));
-        child.on("error", (err) => {
-            clearTimeout(timer);
-            reject(err);
-        });
-        child.on("close", (code) => {
-            clearTimeout(timer);
-            const stdout = Buffer.concat(outChunks).toString("utf-8");
-            const stderr = Buffer.concat(errChunks).toString("utf-8");
-            let combined = stdout.replace(/\s+$/, "");
-            if (stderr)
-                combined += (combined ? "\n" : "") + stderr.replace(/\s+$/, "");
-            if (killedCap) {
-                combined +=
-                    `\n\n[bash] Output collection stopped: exceeded ${COLLECT_HARD_CAP_BYTES} bytes in-memory cap (process was killed). Prefer redirecting to a file (e.g. > out.txt) then read with startLine/endLine.`;
-            }
-            else if (killedTimeout) {
-                combined += `\n\n[bash] Command exceeded timeout ${timeoutMs} ms (process terminated).`;
-            }
-            resolve({
-                code,
-                output: combined || "(no output)",
-                killedByTimeout: killedTimeout,
-                killedByCap: killedCap,
-            });
-        });
-    });
-}
 export const bashTool = tool({
-    description: "Run a shell command. Use this for system operations, running builds, tests, git commands, etc. The command runs in the current working directory. Very long stdout/stderr is truncated: full output may be saved under ~/.min-agent/tool-output/ with a preview returned.",
+    description: "Run a shell command. Use this for system operations, running builds, tests, git commands, etc. The command runs in the current working directory. You SHOULD set a timeout based on how long you expect the command to take. If no timeout is set, the command runs until it finishes or the user manually interrupts (Ctrl+C).",
     inputSchema: jsonSchema({
         type: "object",
         properties: {
             command: { type: "string", description: "The shell command to execute" },
-            timeout: { type: "number", description: "Timeout in milliseconds (default: 30000)" },
+            timeout: { type: "number", description: "Timeout in milliseconds. Set based on expected duration (e.g. 5000 for quick commands, 60000 for builds). Omit only for commands with unpredictable duration." },
         },
         required: ["command"],
     }),
@@ -76,18 +17,84 @@ export const bashTool = tool({
             if (!approved)
                 return "Command rejected by user.";
         }
-        const timeoutMs = timeout ?? 30000;
-        try {
-            const { code, output, killedByTimeout, killedByCap } = await runCommand(command, process.cwd(), timeoutMs);
-            let body = output;
-            if (code !== 0 && code !== null && !killedByTimeout && !killedByCap) {
-                body = `Exit code ${code}\n${body}`;
+        return new Promise((resolve) => {
+            const chunks = [];
+            let killed = false;
+            let timer;
+            const proc = spawn(command, [], {
+                shell: true,
+                cwd: process.cwd(),
+                stdio: ["ignore", "pipe", "pipe"],
+                detached: process.platform !== "win32",
+            });
+            proc.stdout?.on("data", (chunk) => chunks.push(chunk));
+            proc.stderr?.on("data", (chunk) => chunks.push(chunk));
+            // Timeout kill (only if timeout is specified)
+            if (timeout && timeout > 0) {
+                timer = setTimeout(() => {
+                    killed = true;
+                    killProcess(proc.pid);
+                    resolve(getOutput(chunks) +
+                        `\n\n[Command timed out after ${timeout}ms and was killed. Retry with a larger timeout if needed.]`);
+                }, timeout);
             }
-            const { content } = truncateToolOutput(body, { direction: "tail" });
-            return content.trim() || "(no output)";
-        }
-        catch (err) {
-            return `Error: ${err.message ?? String(err)}`;
-        }
+            // Allow user to interrupt with Ctrl+C (SIGINT)
+            const sigintHandler = () => {
+                killed = true;
+                if (timer)
+                    clearTimeout(timer);
+                killProcess(proc.pid);
+                resolve(getOutput(chunks) + "\n\n[Command interrupted by user.]");
+            };
+            process.on("SIGINT", sigintHandler);
+            proc.on("close", (code) => {
+                process.removeListener("SIGINT", sigintHandler);
+                if (timer)
+                    clearTimeout(timer);
+                if (killed)
+                    return;
+                const output = getOutput(chunks);
+                if (code === 0) {
+                    resolve(output || "(no output)");
+                }
+                else {
+                    resolve(`Exit code ${code}\n${output || "(no output)"}`);
+                }
+            });
+            proc.on("error", (err) => {
+                process.removeListener("SIGINT", sigintHandler);
+                if (timer)
+                    clearTimeout(timer);
+                if (killed)
+                    return;
+                resolve(`Error: ${err.message}`);
+            });
+        });
     },
 });
+function getOutput(chunks) {
+    const output = Buffer.concat(chunks).toString("utf-8").trim();
+    if (output.length > 100_000) {
+        return output.slice(0, 50_000) + `\n\n...(truncated, ${output.length} bytes total)...\n\n` + output.slice(-10_000);
+    }
+    return output;
+}
+function killProcess(pid) {
+    if (!pid)
+        return;
+    try {
+        if (process.platform !== "win32") {
+            process.kill(-pid, "SIGTERM");
+            setTimeout(() => {
+                try {
+                    process.kill(-pid, "SIGKILL");
+                }
+                catch { }
+            }, 3000);
+        }
+        else {
+            process.kill(pid, "SIGTERM");
+        }
+    }
+    catch { }
+}