@xingjisoft/neutrino 0.5.1 → 0.6.0

package/dist/pro/agents.js

@@ -1,7 +1,9 @@
 import { LLMClient } from "../llm/client.js";
-import { buildSubAgentTask, formatSubAgentResult, runSubAgent } from "../llm/subagent.js";
+import { buildSubAgentTask, formatSubAgentResult, runSubAgent, subAgentRounds } from "../llm/subagent.js";
 import { DELEGATE_TOOL, getSubAgentToolDefinitions } from "../llm/tools.js";
+import { loadConfig } from "../config.js";
 import { ACTIVE_PRO_ROLES, PRO_ROLES, loadProPrompt } from "./config.js";
+import { currentTask, TaskRuntime, TaskControlError, taskLimits } from "../llm/runtime.js";
 export const PRO_AGENT_TOOL = "call_pro_agent";
 const CALL_AGENT = {
     type: "function",
@@ -16,6 +18,8 @@ const CALL_AGENT = {
                 role: { type: "string", enum: [...ACTIVE_PRO_ROLES] },
                 task: { type: "string", description: "Complete task, expected deliverables and acceptance criteria." },
                 context: { type: "string", description: "Relevant evidence, constraints and decisions; the agent cannot see the parent's conversation." },
+                read_only: { type: "boolean", description: "Restrict this task and all descendants to read-only tools." },
+                write_paths: { type: "array", items: { type: "string" }, description: "Optional allowed write paths. Descendants can only narrow this scope; arbitrary shell commands are unavailable under a path restriction." },
                 reason: { type: "string", description: "Why this specialist is needed for the user's request." },
             },
             required: ["role", "task", "reason"],
@@ -28,10 +32,12 @@ export function getProToolDefinitions() {
 }
 /** A resolved model team belongs to one task; substitutions never touch disk. */
 export class ProAgentTeam {
+    runtime;
     options;
     maxDepth;
     constructor(options) {
         this.options = options;
+        this.runtime = options.runtime ?? currentTask()?.runtime ?? new TaskRuntime({ request: options.request ?? "", cwd: options.cwd, limits: taskLimits(loadConfig("pro")) });
         this.maxDepth = Number.isSafeInteger(options.maxDepth) && options.maxDepth > 0 ? options.maxDepth : 10;
     }
     client(role) {
@@ -40,36 +46,56 @@ export class ProAgentTeam {
             throw new Error(`Pro agent ${role} is unavailable`);
         return new LLMClient(selection.model, selection.provider, selection.intensity, { professional: true });
     }
-    async call(role, task, context = "", depth = 1, readOnly = false) {
+    async call(role, task, context = "", depth = 1, readOnly = false, writePaths) {
+        return formatSubAgentResult(await this.callResult(role, task, context, depth, readOnly, writePaths));
+    }
+    contextWindow(role) {
+        const selection = this.options.models[role];
+        const overrides = loadConfig("pro").model_context_windows;
+        const value = selection && overrides?.[`${selection.provider}/${selection.model.name}`];
+        return typeof value === "number" && Number.isSafeInteger(value) && value > 0 ? value : selection?.context_window ?? 1_000_000;
+    }
+    async callResult(role, task, context = "", depth = 1, readOnly = false, writePaths) {
+        const failure = (code, message) => {
+            const result = { runId: currentTask()?.runId ?? this.runtime.rootRunId,
+                status: code === "cancelled" ? "cancelled" : "failed", report: "", evidenceIds: [], artifacts: [], blockers: [],
+                error: { code, message }, aborted: code === "cancelled", exhausted: false, rounds: 0, calls: 0 };
+            this.runtime.recordResult(result);
+            return result;
+        };
         if (!PRO_ROLES.includes(role))
-            return "[Error: unknown Pro agent role]";
+            return failure("unknown_role", "unknown Pro agent role");
         if (role === "genimage_model")
-            return "[Error: image generation is reserved and is not enabled]";
-        if (this.options.cancelled())
-            return "[Pro agent stopped: the turn was paused or replaced.]";
+            return failure("reserved", "image generation is reserved and is not enabled");
+        if (this.options.cancelled() || this.runtime.signal.aborted)
+            return failure("cancelled", "the turn was paused or replaced");
         if (!Number.isSafeInteger(depth) || depth < 0 || depth > this.maxDepth) {
-            return `[Error: Pro agent recursion limit (${this.maxDepth}) reached. Complete the work without further delegation.]`;
+            return failure("recursion_limit", `Pro agent recursion limit (${this.maxDepth}) reached. Complete the work without further delegation.`);
         }
         if (typeof task !== "string" || !task.trim())
-            return "[Error: a Pro agent needs a nonempty task]";
+            return failure("invalid_task", "a Pro agent needs a nonempty task");
         const selection = this.options.models[role];
         if (!selection)
-            return `[Error: Pro agent ${role} is unavailable]`;
+            return failure("unavailable", `Pro agent ${role} is unavailable`);
         // Reviewers are always read-only, including when consulted as specialists.
-        const onlyRead = readOnly || role === "confirm_model";
+        const parent = currentTask()?.runtime === this.runtime ? currentTask() : this.runtime.root;
+        const onlyRead = readOnly || role === "confirm_model" || parent.policy.readOnly;
         const tools = getProToolDefinitions().filter((tool) => !onlyRead ||
-            ["read_file", "list_files", PRO_AGENT_TOOL].includes(tool.function.name));
+            ["read_file", "list_files", "web_search", PRO_AGENT_TOOL].includes(tool.function.name));
         const names = new Set(tools.map((tool) => tool.function.name));
         const label = `${role} · ${selection.model.name} · ${depth}/${this.maxDepth}`;
         try {
-            const result = await runSubAgent({
+            const maxRounds = subAgentRounds(loadConfig("pro").subagent_max_rounds);
+            return await this.runtime.child(role, task, async (scope) => runSubAgent({
+                runtime: this.runtime, scope,
                 createClient: () => this.client(role),
                 system: `${loadProPrompt(role)}\n\nDelegation depth: ${depth}/${this.maxDepth}. ` +
                     (onlyRead ? "This consultation is read-only. Do not modify files or execute commands, including through another agent." :
                         "Use the shared approval gate for every tool call. Return a self-contained report with changes, evidence and unresolved work."),
-                task: buildSubAgentTask({ task, context, cwd: this.options.cwd }),
+                task: buildSubAgentTask({ task, context, cwd: this.options.cwd, rounds: maxRounds }),
                 tools,
-                contextWindow: selection.context_window,
+                contextWindow: this.contextWindow(role),
+                maxRounds,
                 approve: (name, args) => {
                     if (!names.has(name) && name !== DELEGATE_TOOL)
                         return Promise.resolve({
@@ -82,8 +108,9 @@ export class ProAgentTeam {
                         const nextRole = typeof args.role === "string" ? args.role : "backend_output_model";
                         const nextTask = typeof args.task === "string" ? args.task : "";
                         const nextContext = typeof args.context === "string" ? args.context : "";
-                        const report = await this.call(nextRole, nextTask, nextContext, depth + 1, onlyRead);
-                        this.options.onProgress?.(label);
+                        const report = await this.call(nextRole, nextTask, nextContext, depth + 1, onlyRead || args.read_only === true, Array.isArray(args.write_paths) ? args.write_paths.filter((p) => typeof p === "string") : undefined);
+                        if (!this.options.cancelled() && !this.runtime.signal.aborted)
+                            this.options.onProgress?.(label);
                         return report;
                     }
                     if (!names.has(name))
@@ -94,11 +121,14 @@ export class ProAgentTeam {
                 onUsage: this.options.onUsage,
                 onRetry: this.options.onRetry,
                 onProgress: (activity) => this.options.onProgress?.(`${label} · ${activity}`),
-            });
-            return formatSubAgentResult(result);
+            }), { readOnly: onlyRead, writePaths });
+        }
+        catch (error) {
+            return failure(error instanceof TaskControlError ? error.code : "agent_error", error instanceof Error ? error.message : String(error));
         }
         finally {
-            this.options.onProgress?.(null);
+            if (!this.options.cancelled() && !this.runtime.signal.aborted)
+                this.options.onProgress?.(null);
         }
     }
 }

package/dist/pro/preflight.js

@@ -1,4 +1,7 @@
 import { loadModels } from "../config.js";
+import { completionLimit } from "../llm/client.js";
+import { currentTask, TaskControlError } from "../llm/runtime.js";
+import { inputTokenBound, DEFAULT_OUTPUT_TOKENS } from "../llm/context.js";
 import { ACTIVE_PRO_ROLES, loadProModels, } from "./config.js";
 export class ProPreflightError extends Error {
     fallbacks;
@@ -50,6 +53,13 @@ function resolveSetting(role, preset, catalog) {
 /** An authenticated, tiny inference validates the same intensity/tool contract. */
 async function probe(model, options) {
     const controller = new AbortController();
+    const runtime = currentTask()?.runtime;
+    const outputTokens = runtime ? DEFAULT_OUTPUT_TOKENS : 4096;
+    const release = runtime?.activity();
+    const rootAbort = () => controller.abort(runtime?.signal.reason);
+    runtime?.signal.addEventListener("abort", rootAbort, { once: true });
+    if (runtime?.signal.aborted)
+        rootAbort();
     const relay = () => controller.abort(options.signal?.reason);
     if (options.signal?.aborted)
         relay();
@@ -62,16 +72,20 @@ async function probe(model, options) {
         name: "pro_availability_check", description: "A harmless availability check; this tool is never executed.",
     };
     const payload = anthropic ? {
-        model: model.model.name, stream: false, max_tokens: 4096,
+        model: model.model.name, stream: false, max_tokens: outputTokens,
         output_config: { effort: model.intensity },
         messages: [{ role: "user", content: "Availability check. Reply only OK. Do not call tools." }],
         tools: [{ ...tool, input_schema: parameters }],
     } : {
         model: model.model.name, stream: false, reasoning_effort: model.intensity,
+        ...(runtime ? completionLimit(model.model, model.provider, outputTokens) : {}),
         messages: [{ role: "user", content: "Availability check. Reply only OK. Do not call tools." }],
         tools: [{ type: "function", function: { ...tool, parameters } }],
     };
+    let reservation;
+    let used = inputTokenBound(payload) + outputTokens;
     try {
+        reservation = runtime?.request(inputTokenBound(payload), outputTokens);
         const response = await fetch(model.model.url.replace(/\/+$/, "") + (anthropic ? "/messages" : "/chat/completions"), {
             method: "POST", signal: controller.signal,
             headers: {
@@ -94,16 +108,24 @@ async function probe(model, options) {
         if (body.usage) {
             const prompt = body.usage.prompt_tokens ?? body.usage.input_tokens ?? 0;
             const completion = body.usage.completion_tokens ?? body.usage.output_tokens ?? 0;
+            used = prompt + completion;
             options.onUsage?.({ prompt, completion, total: prompt + completion });
         }
         return { ok: true, reason: "" };
     }
-    catch {
+    catch (error) {
+        if (error instanceof TaskControlError)
+            throw error;
+        if (runtime?.signal.aborted)
+            throw new Error("Pro availability check was cancelled");
         if (options.signal?.aborted)
             throw new Error("Pro availability check was cancelled");
         return { ok: false, reason: controller.signal.aborted ? "availability request timed out" : "availability request failed" };
     }
     finally {
+        reservation?.settle(used);
+        release?.();
+        runtime?.signal.removeEventListener("abort", rootAbort);
         clearTimeout(timer);
         options.signal?.removeEventListener("abort", relay);
     }