micro-models-agent 0.8.0 → 0.10.0

package/dist/tools/pipeline-run.js

@@ -1,7 +1,56 @@
 import { t } from '../i18n/index';
 import { PipelineEngine } from '../modules/pipelines/engine';
 import { PipelineParser } from '../modules/pipelines/parser';
+import { TemplateEngine } from '../modules/pipelines/template';
+import { Agent } from '../core/agent';
+import { ContextManager } from '../modules/context/manager';
+import { PluginManager } from '../modules/plugins/manager';
+import { HallucinationDetector } from '../modules/hallucination/detector';
+import { logSecurityBlock } from '../modules/security/audit-log';
+import { getSessionSecurityConfig } from '../modules/security/session-isolation';
 const engine = new PipelineEngine();
+const MAX_CONCURRENT = 3;
+const MAX_ATTEMPTS = 3;
+async function runStep(ctx, step, params, outputs) {
+    const prompt = TemplateEngine.render(step.prompt, params, outputs);
+    let lastError = "";
+    for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
+        try {
+            const subContextManager = new ContextManager(ctx.config.contextWindow, ctx.config.contextBudget);
+            const subPluginManager = new PluginManager();
+            const systemPrompt = {
+                content: `You are a pipeline step agent ("${step.agent}"). Complete the given task using the available tools.`,
+                priority: "critical",
+                essential: true,
+                estimatedTokens: 80,
+            };
+            const subDeps = {
+                config: ctx.config,
+                llmProvider: ctx.llmProvider,
+                toolExecutor: ctx.toolExecutor,
+                pluginManager: subPluginManager,
+                contextManager: subContextManager,
+                hallucinationDetector: new HallucinationDetector(),
+                logger: ctx.logger,
+                baseDir: ctx.baseDir,
+                scope: ctx.scope,
+                recursionDepth: (ctx.recursionDepth ?? 0) + 1,
+                promptBlocks: [systemPrompt],
+            };
+            const subAgent = new Agent(subDeps);
+            const result = await subAgent.run(prompt);
+            if (result.success) {
+                return { ok: true, output: result.text };
+            }
+            lastError = result.error || "no output";
+        }
+        catch (e) {
+            lastError = e.message;
+        }
+        await new Promise((r) => setTimeout(r, 500 * attempt));
+    }
+    return { ok: false, output: "", error: lastError };
+}
 export const pipelineRunTool = {
     name: 'pipeline_run',
     description: 'Run a named pipeline with YAML definition. Creates a DAG of sub-agents that execute in dependency order.',
@@ -11,26 +60,82 @@ export const pipelineRunTool = {
         properties: {
             name: { type: 'string', description: 'Pipeline name' },
             yaml: { type: 'string', description: 'Pipeline YAML definition with steps' },
+            params: { type: 'object', description: 'Template params for {key} placeholders' },
         },
         required: ['name', 'yaml'],
     },
-    handler: async (_ctx, args) => {
+    handler: async (ctx, args) => {
         const name = String(args.name || '');
         const yaml = String(args.yaml || '');
+        const params = args.params || {};
         if (!yaml) {
             return { success: false, output: t('pipeline.invalid') };
         }
+        if (!ctx.llmProvider || !ctx.toolExecutor) {
+            return {
+                success: false,
+                output: 'Pipeline cannot run: missing llmProvider or toolExecutor in context',
+            };
+        }
+        const securityConfig = ctx.sessionContext
+            ? getSessionSecurityConfig(ctx.config, ctx.sessionContext)
+            : ctx.config.security;
+        const maxDepth = securityConfig?.maxRecursionDepth ?? 3;
+        const currentDepth = ctx.recursionDepth ?? 0;
+        if (currentDepth >= maxDepth) {
+            logSecurityBlock(ctx.sessionId, "bash_command", `Maximum recursion depth (${maxDepth}) exceeded`, name);
+            return {
+                success: false,
+                output: `[SECURITY BLOCKED] Maximum pipeline recursion depth (${maxDepth}) exceeded`,
+            };
+        }
         try {
             const pipeline = PipelineParser.parse(yaml);
+            engine.reset();
             const order = engine.resolveDependencies(pipeline.steps);
-            const readySteps = engine.getReadySteps(pipeline.steps, new Set());
-            const summary = [
-                `Pipeline "${pipeline.name}" parsed successfully.`,
-                `Steps: ${pipeline.steps.length}`,
-                `Execution order: ${order.join(' → ')}`,
-                `Ready to run: ${readySteps.map(s => s.id).join(', ') || '(none)'}`,
-            ].join('\n');
-            return { success: true, output: summary };
+            const completed = new Set();
+            const outputs = {};
+            const logs = [];
+            const failed = new Set();
+            while (completed.size < pipeline.steps.length) {
+                const ready = engine
+                    .getReadySteps(pipeline.steps, completed)
+                    .filter((s) => !failed.has(s.id));
+                if (ready.length === 0) {
+                    if (failed.size > 0)
+                        break;
+                    throw new Error(t('pipeline.circular', { stepId: order.join(', ') }));
+                }
+                const batch = ready.slice(0, MAX_CONCURRENT);
+                const results = await Promise.all(batch.map((step) => runStep(ctx, step, params, outputs)));
+                for (let i = 0; i < batch.length; i++) {
+                    const step = batch[i];
+                    const result = results[i];
+                    if (result.ok) {
+                        completed.add(step.id);
+                        outputs[step.id] = { output: result.output };
+                        engine.setStepStatus(step.id, 'done');
+                        logs.push(`  ✓ ${step.id}: ${result.output.split("\n")[0]}`);
+                    }
+                    else {
+                        failed.add(step.id);
+                        engine.setStepStatus(step.id, 'failed');
+                        logs.push(`  ✗ ${step.id}: ${result.error}`);
+                    }
+                }
+                if (failed.size > 0)
+                    break;
+            }
+            if (failed.size > 0) {
+                return {
+                    success: false,
+                    output: `Pipeline "${pipeline.name}" failed. Executed ${completed.size}/${pipeline.steps.length} steps.\n${logs.join("\n")}`,
+                };
+            }
+            return {
+                success: true,
+                output: `Pipeline "${pipeline.name}" completed successfully (${completed.size} steps).\n${logs.join("\n")}`,
+            };
         }
         catch (e) {
             return { success: false, output: `Pipeline error: ${e.message}` };

package/dist/tools/process-kill.js

@@ -0,0 +1,29 @@
+import { processRegistry } from '../modules/processes';
+import { t } from '../i18n/index';
+export const processKillTool = {
+    name: 'process_kill',
+    description: 'Stop a background process started via bash (dev server, watcher). Kills the whole process tree (children included). Use the id returned by bash or process_list.',
+    tags: ['shell'],
+    parameters: {
+        type: 'object',
+        properties: {
+            id: { type: 'string', description: 'Process id from bash output or process_list' },
+        },
+        required: ['id'],
+    },
+    handler: async (ctx, args) => {
+        const id = String(args.id);
+        const entry = processRegistry.get(id);
+        if (!entry) {
+            return { success: false, output: t('proc.not_found', { id }) };
+        }
+        const killed = processRegistry.kill(id);
+        if (!killed) {
+            return { success: false, output: t('proc.kill_failed', { id }) };
+        }
+        return {
+            success: true,
+            output: t('proc.killed', { id, pid: entry.pid }),
+        };
+    },
+};

package/dist/tools/process-list.js

@@ -0,0 +1,38 @@
+import { processRegistry } from '../modules/processes';
+import { t } from '../i18n/index';
+export const processListTool = {
+    name: 'process_list',
+    description: 'List background processes started via the bash tool (dev servers, watchers, long-running commands). Shows id, pid, command, status, and recent output. Use with process_log and process_kill to inspect or stop them.',
+    tags: ['shell'],
+    parameters: {
+        type: 'object',
+        properties: {},
+    },
+    handler: async (ctx) => {
+        const list = processRegistry.list(ctx.sessionId);
+        if (list.length === 0) {
+            return { success: true, output: t('proc.none') };
+        }
+        const statusLabel = (status) => {
+            if (status === 'running')
+                return t('proc.status_running');
+            if (status === 'exited')
+                return t('proc.status_exited');
+            return t('proc.status_killed');
+        };
+        const lines = [`${t('proc.list_header')} (${list.length}):`];
+        for (const entry of list) {
+            const tail = entry.log.length > 0 ? entry.log[entry.log.length - 1] : '';
+            const detail = tail
+                ? ` — ${tail.slice(0, 80)}${tail.length > 80 ? '…' : ''}`
+                : '';
+            lines.push(`  ${entry.id}  PID ${entry.pid}  ${statusLabel(entry.status)}  ${entry.command}${detail}`);
+        }
+        lines.push(`\n${t('proc.hint', {
+            list: 'process_list',
+            log: 'process_log',
+            kill: 'process_kill',
+        })}`);
+        return { success: true, output: lines.join('\n') };
+    },
+};

package/dist/tools/process-log.js

@@ -0,0 +1,39 @@
+import { processRegistry } from '../modules/processes';
+import { t } from '../i18n/index';
+export const processLogTool = {
+    name: 'process_log',
+    description: 'Show the buffered output of a background process started via bash. Use after starting a dev server to verify it came up without errors, and while it runs to check its state.',
+    tags: ['shell'],
+    parameters: {
+        type: 'object',
+        properties: {
+            id: { type: 'string', description: 'Process id from bash output or process_list' },
+            tail: { type: 'number', description: 'Number of trailing lines to show (default: all buffered lines, max 300)' },
+        },
+        required: ['id'],
+    },
+    handler: async (ctx, args) => {
+        const id = String(args.id);
+        const entry = processRegistry.get(id);
+        if (!entry) {
+            return { success: false, output: t('proc.not_found', { id }) };
+        }
+        const status = entry.status === 'running'
+            ? t('proc.status_running')
+            : entry.status === 'exited'
+                ? t('proc.status_exited')
+                : t('proc.status_killed');
+        const tail = typeof args.tail === 'number' ? args.tail : undefined;
+        const log = processRegistry.getLog(id, tail);
+        if (!log) {
+            return {
+                success: true,
+                output: `${t('proc.log_header', { id, status })} ${t('proc.log_empty')}`,
+            };
+        }
+        return {
+            success: true,
+            output: `${t('proc.log_header', { id, status })}\n${log}`,
+        };
+    },
+};

package/dist/tools/read-file.js

@@ -2,6 +2,8 @@ import { readFileSync, existsSync } from "fs";
 import { resolve, normalize, extname } from "path";
 import { t } from "../i18n/index";
 import { isPathInScope } from "../modules/security/path-validator";
+import { DEFAULT_SECURITY_CONFIG } from "../config/security";
+import { logSecurityBlock } from "../modules/security/audit-log";
 /** Default number of lines returned when the caller omits `limit`. */
 const DEFAULT_LIMIT = 300;
 export const readFileTool = {
@@ -25,8 +27,11 @@ export const readFileTool = {
     },
     handler: async (ctx, args) => {
         const path = String(args.path);
-        const scopeCheck = isPathInScope(ctx.baseDir, path, ctx.scope, ctx.config.security?.paths);
+        const securityPaths = ctx.config?.security?.paths || DEFAULT_SECURITY_CONFIG.paths;
+        const scopeCheck = isPathInScope(ctx.baseDir, path, ctx.scope, securityPaths);
         if (!scopeCheck.allowed) {
+            const pathStr = path;
+            logSecurityBlock(ctx.sessionId || undefined, "file_read", scopeCheck.reason || "Path not allowed", pathStr);
             return {
                 success: false,
                 output: t("file.path_not_allowed", {

package/dist/tools/subagent.js

@@ -83,6 +83,18 @@ export const subagentTool = {
                 output: "Sub-agent cannot run: missing llmProvider or toolExecutor in context",
             };
         }
+        // Defensive guard: if the caller requested specific tool tags but none of the
+        // registered tools match, the sub-agent would have zero tools and would
+        // hallucinate instead of acting. Warn the caller so it can correct the tags.
+        if (toolTags && toolTags.length > 0) {
+            const matched = ctx.toolExecutor.getToolDefinitions(toolTags);
+            if (matched.length === 0) {
+                return {
+                    success: false,
+                    output: `[SECURITY BLOCKED] No tools match the requested tool_tags: [${toolTags.join(", ")}]. Check the subagent tool_tags parameter and retry with valid tags (e.g. "file", "code", "shell", "research").`,
+                };
+            }
+        }
         try {
             const subContextManager = new ContextManager(ctx.config.contextWindow, ctx.config.contextBudget);
             const subPluginManager = new PluginManager();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "micro-models-agent",
-  "version": "0.8.0",
+  "version": "0.10.0",
   "description": "Micro Models Agent (MMA) — LLM agent harness for small models (Qwen3.5-9B, 32K-64K context)",
   "type": "module",
   "bin": {