min-agent 0.2.1 → 0.4.0

package/dist/tools/task.js

@@ -1,14 +1,24 @@
 import { tool, jsonSchema, streamText, stepCountIs } from "ai";
 import { resolveModel } from "../provider.js";
 import { createTools } from "./index.js";
-import { getMcpTools } from "../mcp.js";
-import { getSkillsTool, getSkills } from "../skills.js";
+import { getMcpTools, getMcpCatalogTools } from "../mcp.js";
+import { attachSkills } from "../skills.js";
 import { loadPluginTools } from "../plugins.js";
 import { DoomLoopDetector } from "../doom-loop.js";
+import { log } from "../logger.js";
+import { getEffectiveConfig } from "../config.js";
 import { stripThinkingFromAssistantText } from "../assistant-stream.js";
+import { unwrapXmlSearchTags } from "../xml-search.js";
 import { truncateToolOutput } from "../tool-output.js";
+import { createTodoTool } from "./todo.js";
 const SUB_AGENT_MAX_STEPS = 15;
-const SUB_AGENT_SYSTEM = `You are a focused sub-agent executing a specific task. Complete the task thoroughly and return a clear result.
+function resolveSubAgentSteps(explicit) {
+    const configured = getEffectiveConfig().agent?.subAgentMaxSteps;
+    const value = explicit ?? configured ?? SUB_AGENT_MAX_STEPS;
+    return Number.isFinite(value) && value >= 1 ? Math.floor(value) : SUB_AGENT_MAX_STEPS;
+}
+function subAgentSystem() {
+    return `You are a focused sub-agent executing a specific task. Complete the task thoroughly and return a clear result.
 
 Rules:
 - Focus only on the assigned task
@@ -19,7 +29,16 @@ Rules:
 Working directory: ${process.cwd()}
 Platform: ${process.platform}
 Date: ${new Date().toDateString()}`;
-export function createTaskTool(modelId) {
+}
+let listener = null;
+export function setSubAgentListener(fn) {
+    listener = fn;
+}
+function logSub(line) {
+    if (!listener)
+        console.error(line);
+}
+export function createTaskTool(modelId, abortSignal, onUsage, context = {}) {
     return tool({
         description: `Launch a sub-agent to execute a task independently. The sub-agent has its own context and tools. Use this for:
 - Parallel execution: call multiple tasks at once for independent work
@@ -36,44 +55,56 @@ Call multiple tasks in parallel when the work is independent.`,
             },
             required: ["description", "prompt"],
         }),
-        execute: async ({ description, prompt }) => {
-            console.log(`\x1b[90m  ┌─ Sub-agent: ${description}\x1b[0m`);
+        execute: async ({ description, prompt }, options) => {
+            const parentToolCallId = options?.toolCallId;
+            logSub(`\x1b[90m  ┌─ Sub-agent: ${description}\x1b[0m`);
             try {
-                const result = await runSubAgent(prompt, modelId);
-                console.log(`\x1b[90m  └─ ✓ Done\x1b[0m`);
-                return truncateToolOutput(result, { direction: "head" }).content;
+                const result = await runSubAgent(prompt, modelId, abortSignal, parentToolCallId, context);
+                if (result.usage)
+                    onUsage?.(result.usage);
+                logSub(`\x1b[90m  └─ ✓ Done\x1b[0m`);
+                return truncateToolOutput(result.text, { direction: "tail" }).content;
             }
             catch (err) {
-                console.log(`\x1b[90m  └─ ✗ Failed: ${err.message}\x1b[0m`);
-                return `Sub-agent error: ${err.message}`;
+                if (abortSignal?.aborted)
+                    return "Sub-agent cancelled by user.";
+                const message = err instanceof Error ? err.message : String(err);
+                log("error", `sub-agent failed: ${message}`);
+                logSub(`\x1b[90m  └─ ✗ Failed: ${message}\x1b[0m`);
+                return `Sub-agent error: ${message}`;
             }
         },
     });
 }
-async function runSubAgent(prompt, modelId) {
+async function runSubAgent(prompt, modelId, abortSignal, parentToolCallId, context = {}) {
     const model = resolveModel(modelId);
-    // Build tools for sub-agent (no task tool to prevent recursion)
     const builtinTools = createTools();
+    builtinTools.todo = createTodoTool({ silent: true });
     const mcpTools = getMcpTools();
+    const catalogTools = getMcpCatalogTools();
     const pluginTools = await loadPluginTools();
-    const skills = getSkills();
-    const allTools = { ...builtinTools, ...pluginTools };
-    for (const [id, t] of Object.entries(mcpTools))
-        allTools[id] = t;
-    if (skills.length > 0)
-        allTools["skill"] = getSkillsTool();
-    // Remove task tool from sub-agent to prevent infinite recursion
-    delete allTools["task"];
+    const allTools = { ...builtinTools, ...pluginTools, ...mcpTools, ...catalogTools };
+    const skillsPrompt = attachSkills(allTools);
+    // Remove task/explore tools from sub-agent to prevent infinite recursion
+    delete allTools.task;
+    delete allTools.explore;
     const messages = [{ role: "user", content: prompt }];
-    const doomLoop = new DoomLoopDetector();
+    // Sharing the parent guard means the child cannot restart the research budget.
+    const doomLoop = context.loopGuard ?? new DoomLoopDetector();
+    const maxSteps = resolveSubAgentSteps(context.maxSteps);
+    const controller = new AbortController();
+    const signal = abortSignal ? AbortSignal.any([abortSignal, controller.signal]) : controller.signal;
     const result = streamText({
         model,
-        system: SUB_AGENT_SYSTEM,
+        system: skillsPrompt ? `${subAgentSystem()}\n\n${skillsPrompt}` : subAgentSystem(),
         messages,
         tools: allTools,
-        stopWhen: stepCountIs(SUB_AGENT_MAX_STEPS),
+        stopWhen: stepCountIs(maxSteps),
         maxRetries: 2,
-        onError() { },
+        abortSignal: signal,
+        onError({ error }) {
+            log("warn", `sub-agent step failed (will retry): ${String(error)}`);
+        },
     });
     let assistantText = "";
     for await (const event of result.fullStream) {
@@ -81,18 +112,54 @@ async function runSubAgent(prompt, modelId) {
             case "text-delta":
                 assistantText += event.text;
                 break;
-            case "tool-call":
-                if (doomLoop.record(event.toolName, event.input)) {
-                    return assistantText + "\n\n[Sub-agent stopped: doom loop detected]";
+            case "tool-call": {
+                const action = doomLoop.observe(event.toolName, event.input);
+                if (action === "halt" || action === "cap") {
+                    controller.abort();
+                    const note = action === "halt"
+                        ? "[Sub-agent stopped: repeated the same action too many times]"
+                        : "[Sub-agent stopped: too many web searches. Summarize what was found.]";
+                    return { text: unwrapXmlSearchTags(assistantText) + "\n\n" + note };
                 }
-                console.log(`\x1b[90m  │ ⚡ ${event.toolName}\x1b[0m`);
+                listener?.({ parentToolCallId, name: event.toolName, input: event.input, phase: "call" });
+                logSub(`\x1b[90m  │ ⚡ ${event.toolName}\x1b[0m`);
                 break;
-            case "tool-result":
+            }
+            case "tool-result": {
+                listener?.({
+                    parentToolCallId,
+                    name: event.toolName,
+                    output: event.output,
+                    phase: "result",
+                });
+                const action = doomLoop.observeResult(event.toolName, event.output);
+                if (action === "cap") {
+                    controller.abort();
+                    return {
+                        text: unwrapXmlSearchTags(assistantText) +
+                            "\n\n[Sub-agent stopped: research budget spent. Summarize what was found.]",
+                    };
+                }
+                if (context.shouldStop?.()) {
+                    log("warn", "sub-agent stopped: parent budget reached");
+                    controller.abort();
+                    return {
+                        text: unwrapXmlSearchTags(assistantText) + "\n\n[Sub-agent stopped: run budget reached]",
+                    };
+                }
                 break;
+            }
             case "error":
-                return assistantText + `\n\n[Sub-agent error: ${event.error}]`;
+                log("error", `sub-agent stream error: ${String(event.error)}`);
+                controller.abort();
+                return { text: unwrapXmlSearchTags(assistantText) + `\n\n[Sub-agent error: ${event.error}]` };
         }
     }
-    const cleaned = stripThinkingFromAssistantText(assistantText);
-    return cleaned || "(sub-agent produced no output)";
+    const cleaned = unwrapXmlSearchTags(stripThinkingFromAssistantText(assistantText));
+    let usage;
+    try {
+        usage = await result.usage;
+    }
+    catch { }
+    return { text: cleaned || "(sub-agent produced no output)", usage };
 }

package/dist/tools/todo.js

@@ -1,44 +1,142 @@
 import { tool, jsonSchema } from "ai";
-let todos = [];
-let nextId = 1;
-export function getTodos() {
-    return todos;
+import { isSyntheticMessage } from "../synthetic.js";
+export const TODO_STATUSES = ["pending", "in_progress", "done", "cancelled"];
+const GOAL_MAX_CHARS = 4000;
+export function emptyTaskState() {
+    return { goal: "", todos: [], nextId: 1 };
 }
-export function resetTodos() {
-    todos = [];
-    nextId = 1;
+export function resetTaskState(state) {
+    state.goal = "";
+    state.todos.length = 0;
+    state.nextId = 1;
 }
-function formatTodos() {
-    if (todos.length === 0)
-        return "No tasks.";
-    const icons = {
-        pending: "○",
-        in_progress: "◐",
-        done: "●",
-        cancelled: "✕",
+export function copyTaskState(from, into) {
+    if (!from) {
+        resetTaskState(into);
+        return;
+    }
+    into.goal = from.goal;
+    into.todos = from.todos.map((t) => ({ ...t }));
+    into.nextId = from.nextId;
+}
+function isTodoStatus(value) {
+    return typeof value === "string" && TODO_STATUSES.includes(value);
+}
+export function parseTaskState(raw) {
+    if (!raw || typeof raw !== "object")
+        return undefined;
+    const rec = raw;
+    const todos = [];
+    if (Array.isArray(rec.todos)) {
+        for (const item of rec.todos) {
+            if (!item || typeof item !== "object")
+                continue;
+            const t = item;
+            if (typeof t.id !== "number" || typeof t.text !== "string")
+                continue;
+            todos.push({
+                id: t.id,
+                text: t.text,
+                status: isTodoStatus(t.status) ? t.status : "pending",
+            });
+        }
+    }
+    const maxId = todos.reduce((m, t) => Math.max(m, t.id), 0);
+    const nextId = typeof rec.nextId === "number" && Number.isFinite(rec.nextId) && rec.nextId > maxId
+        ? Math.floor(rec.nextId)
+        : maxId + 1;
+    return {
+        goal: typeof rec.goal === "string" ? rec.goal : "",
+        todos,
+        nextId,
     };
-    return todos
-        .map((t) => `  ${icons[t.status]} #${t.id} ${t.text}`)
+}
+function messageText(msg) {
+    if (typeof msg.content === "string")
+        return msg.content;
+    if (!Array.isArray(msg.content))
+        return "";
+    return msg.content
+        .filter((p) => p.type === "text" && typeof p.text === "string")
+        .map((p) => p.text)
         .join("\n");
 }
-function printTodos() {
-    if (todos.length === 0)
+/** Keep the first real user request so compaction cannot drop the original goal. */
+export function captureGoal(state, messages) {
+    if (state.goal.trim())
+        return;
+    for (const msg of messages) {
+        if (msg.role !== "user")
+            continue;
+        if (isSyntheticMessage(msg))
+            continue;
+        const text = messageText(msg).trim();
+        if (!text)
+            continue;
+        state.goal = text.slice(0, GOAL_MAX_CHARS);
         return;
-    console.log(`\x1b[90m  ┌─ Tasks${"─".repeat(36)}\x1b[0m`);
-    for (const t of todos) {
-        const icon = t.status === "done" ? "\x1b[32m●\x1b[0m"
-            : t.status === "in_progress" ? "\x1b[33m◐\x1b[0m"
-                : t.status === "cancelled" ? "\x1b[90m✕\x1b[0m"
-                    : "\x1b[90m○\x1b[0m";
-        const dim = t.status === "done" || t.status === "cancelled" ? "\x1b[90m" : "";
-        const reset = dim ? "\x1b[0m" : "";
-        console.log(`\x1b[90m  │\x1b[0m ${icon} ${dim}#${t.id} ${t.text}${reset}`);
     }
-    console.log(`\x1b[90m  └${"─".repeat(44)}\x1b[0m`);
 }
-export const todoTool = tool({
-    description: `Create or update tasks to track progress. Use this FREQUENTLY to:
-- Plan multi-step work by creating tasks upfront
+export function formatTaskStatePrompt(state) {
+    if (!state.goal && state.todos.length === 0)
+        return "";
+    const icons = {
+        pending: "pending",
+        in_progress: "in_progress",
+        done: "done",
+        cancelled: "cancelled",
+    };
+    const lines = [
+        "## Current Task",
+        "This block is the durable task state. It survives context compaction. Keep it accurate with the todo tool.",
+    ];
+    if (state.goal) {
+        lines.push("", "### Original goal", state.goal);
+    }
+    if (state.todos.length > 0) {
+        lines.push("", "### Task list");
+        for (const t of state.todos) {
+            lines.push(`- [${icons[t.status]}] #${t.id} ${t.text}`);
+        }
+    }
+    return lines.join("\n");
+}
+export function createTodoTool(opts) {
+    const silent = opts?.silent ?? false;
+    const store = opts?.store ?? emptyTaskState();
+    const formatTodos = () => {
+        if (store.todos.length === 0)
+            return "No tasks.";
+        const icons = {
+            pending: "○",
+            in_progress: "◐",
+            done: "●",
+            cancelled: "✕",
+        };
+        return store.todos.map((t) => `  ${icons[t.status]} #${t.id} ${t.text}`).join("\n");
+    };
+    const printTodos = () => {
+        if (silent || store.todos.length === 0)
+            return;
+        console.log(`\x1b[90m  ┌─ Tasks${"─".repeat(36)}\x1b[0m`);
+        for (const t of store.todos) {
+            const icon = t.status === "done"
+                ? "\x1b[32m●\x1b[0m"
+                : t.status === "in_progress"
+                    ? "\x1b[33m◐\x1b[0m"
+                    : t.status === "cancelled"
+                        ? "\x1b[90m✕\x1b[0m"
+                        : "\x1b[90m○\x1b[0m";
+            const dim = t.status === "done" || t.status === "cancelled" ? "\x1b[90m" : "";
+            const reset = dim ? "\x1b[0m" : "";
+            console.log(`\x1b[90m  │\x1b[0m ${icon} ${dim}#${t.id} ${t.text}${reset}`);
+        }
+        console.log(`\x1b[90m  └${"─".repeat(44)}\x1b[0m`);
+    };
+    return tool({
+        description: `Create or update tasks to track progress. The list persists across context compaction and auto-continue. Use this FREQUENTLY to:
+- Plan multi-step work by creating tasks upfront (research, then the deliverable)
+- Mark research tasks done before more searching — then write the output
 - Mark tasks as in_progress when starting them
 - Mark tasks as done when completed
 - Give the user visibility into your progress
@@ -46,43 +144,56 @@ export const todoTool = tool({
 To create new tasks: provide items with "text" and optionally "status" (defaults to "pending").
 To update existing tasks: provide items with "id" and "status".
 You can mix creates and updates in one call.`,
-    inputSchema: jsonSchema({
-        type: "object",
-        properties: {
-            todos: {
-                type: "array",
-                description: "List of tasks to create or update",
-                items: {
-                    type: "object",
-                    properties: {
-                        text: { type: "string", description: "Task description (for new tasks)" },
-                        status: { type: "string", description: "Status: pending, in_progress, done, cancelled" },
-                        id: { type: "number", description: "Task ID (for updating existing tasks)" },
+        inputSchema: jsonSchema({
+            type: "object",
+            properties: {
+                todos: {
+                    type: "array",
+                    description: "List of tasks to create or update",
+                    items: {
+                        type: "object",
+                        properties: {
+                            text: { type: "string", description: "Task description (for new tasks)" },
+                            status: { type: "string", description: "Status: pending, in_progress, done, cancelled" },
+                            id: { type: "number", description: "Task ID (for updating existing tasks)" },
+                        },
                     },
                 },
             },
-        },
-        required: ["todos"],
-    }),
-    execute: async ({ todos: items }) => {
-        for (const item of items) {
-            if (item.id) {
-                // Update existing
-                const existing = todos.find((t) => t.id === item.id);
-                if (existing && item.status) {
-                    existing.status = item.status;
+            required: ["todos"],
+        }),
+        execute: async ({ todos: items }) => {
+            const errors = [];
+            for (const item of items) {
+                if (item.id != null) {
+                    const existing = store.todos.find((t) => t.id === item.id);
+                    if (!existing) {
+                        errors.push(`task #${item.id} not found`);
+                        continue;
+                    }
+                    if (item.status) {
+                        if (!TODO_STATUSES.includes(item.status)) {
+                            errors.push(`invalid status "${item.status}" for task #${item.id}`);
+                            continue;
+                        }
+                        existing.status = item.status;
+                    }
+                    if (item.text)
+                        existing.text = item.text;
+                }
+                else if (item.text) {
+                    store.todos.push({
+                        id: store.nextId++,
+                        text: item.text,
+                        status: TODO_STATUSES.includes(item.status) ? item.status : "pending",
+                    });
+                }
+                else {
+                    errors.push("item needs either an id (update) or text (create)");
                 }
             }
-            else if (item.text) {
-                // Create new
-                todos.push({
-                    id: nextId++,
-                    text: item.text,
-                    status: item.status ?? "pending",
-                });
-            }
-        }
-        printTodos();
-        return formatTodos();
-    },
-});
+            printTodos();
+            return errors.length > 0 ? `${formatTodos()}\n\nWarnings: ${errors.join("; ")}` : formatTodos();
+        },
+    });
+}