@nexrall/code-core 1.0.0

package/dist/agent/loop.js

@@ -0,0 +1,775 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runAgentLoop = runAgentLoop;
+const client_1 = require("../api/client");
+const executor_1 = require("../tools/executor");
+const agentTypes_1 = require("./agentTypes");
+const rules_1 = require("../permissions/rules");
+const sandbox_1 = require("../tools/sandbox");
+const index_1 = require("../plugins/index");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+function loadHooks(workDir) {
+    let fromSettings = {};
+    try {
+        const p = path.join(workDir, '.nexrall', 'settings.json');
+        if (fs.existsSync(p))
+            fromSettings = JSON.parse(fs.readFileSync(p, 'utf-8')).hooks ?? {};
+    }
+    catch { /* ignore */ }
+    // Merge plugin-provided hooks AFTER the project's own (project hooks run first).
+    const fromPlugins = (0, index_1.pluginHooks)(workDir);
+    const merged = { ...fromSettings };
+    for (const phase of Object.keys(fromPlugins)) {
+        const extra = fromPlugins[phase];
+        if (!Array.isArray(extra) || !extra.length)
+            continue;
+        merged[phase] = [
+            ...((merged[phase]) ?? []),
+            ...extra,
+        ];
+    }
+    return merged;
+}
+// Run PreToolUse / PostToolUse hooks with a Claude-Code-style control protocol.
+//
+// Each hook command receives a JSON payload on stdin and NEXRALL_TOOL_* env vars.
+// It controls the agent via:
+//   • exit code 2          → BLOCK the tool; stderr becomes the reason
+//   • stdout JSON object    → { "decision": "block"|"allow", "reason": "...",
+//                              "additionalContext": "text to feed the model" }
+//   • any other exit code   → non-blocking (stderr logged, tool proceeds)
+function runToolHooks(entries, phase, toolName, input, workDir, result) {
+    const outcome = { block: false };
+    if (!entries?.length)
+        return outcome;
+    const payload = JSON.stringify({
+        phase,
+        tool: toolName,
+        input,
+        ...(result ? { result: { output: result.output, error: result.error } } : {}),
+    });
+    for (const entry of entries) {
+        if (entry.matcher && entry.matcher !== '*' && !toolName.includes(entry.matcher))
+            continue;
+        for (const hook of entry.hooks ?? []) {
+            if (hook.type !== 'command' || !hook.command)
+                continue;
+            let r;
+            try {
+                r = (0, child_process_1.spawnSync)(hook.command, {
+                    shell: true,
+                    cwd: workDir,
+                    timeout: 10000,
+                    encoding: 'utf-8',
+                    input: payload,
+                    env: {
+                        ...process.env,
+                        NEXRALL_TOOL_NAME: toolName,
+                        NEXRALL_TOOL_INPUT: JSON.stringify(input),
+                        NEXRALL_HOOK_PHASE: phase,
+                    },
+                });
+            }
+            catch {
+                continue; // hook itself failed to spawn — non-fatal
+            }
+            // Optional JSON directive on stdout
+            const out = (r.stdout ?? '').toString().trim();
+            if (out.startsWith('{')) {
+                try {
+                    const j = JSON.parse(out);
+                    if (j.decision === 'block') {
+                        outcome.block = true;
+                        outcome.reason = j.reason ?? outcome.reason ?? 'Blocked by hook';
+                    }
+                    if (typeof j.additionalContext === 'string' && j.additionalContext) {
+                        outcome.context = (outcome.context ? outcome.context + '\n' : '') + j.additionalContext;
+                    }
+                }
+                catch { /* not a directive — ignore */ }
+            }
+            // Exit code 2 → hard block; stderr is the reason fed back to the model
+            if (r.status === 2) {
+                outcome.block = true;
+                const err = (r.stderr ?? '').toString().trim();
+                outcome.reason = err || outcome.reason || `Blocked by ${phase} hook`;
+            }
+        }
+    }
+    return outcome;
+}
+function runSimpleHooks(defs, workDir) {
+    if (!defs?.length)
+        return;
+    for (const hook of defs) {
+        if (hook.type === 'command' && hook.command) {
+            try {
+                (0, child_process_1.spawnSync)(hook.command, { shell: true, cwd: workDir, timeout: 10000 });
+            }
+            catch { /* non-fatal */ }
+        }
+    }
+}
+// ─── Iteration cap ──────────────────────────────────────────────────────────
+// Each iteration is one model response + one round of tool execution. The cap is
+// a runaway-loop backstop, NOT a task-size limit — on a large project a single
+// task can legitimately need well over 50 rounds (read → search → edit → test →
+// fix → …). A too-low cap makes the agent appear to "freeze" mid-task. Keep the
+// default high and let projects raise it further via settings / env.
+const DEFAULT_MAX_ITERATIONS = 500;
+const MAX_ITERATIONS_CEILING = 2000; // absolute backstop — auto-continue never goes past this
+const STALL_LIMIT = 8; // consecutive all-failed tool rounds → give up (runaway guard)
+// Resolve the soft iteration budget. Precedence:
+//   options.maxIterations  →  env NEXRALL_MAX_ITERATIONS  →  settings.maxIterations  →  default
+function resolveMaxIterations(optionValue, settingsRaw) {
+    const fromEnv = Number(process.env.NEXRALL_MAX_ITERATIONS);
+    const fromSettings = Number(settingsRaw.maxIterations);
+    const candidate = (typeof optionValue === 'number' && optionValue > 0) ? optionValue
+        : Number.isFinite(fromEnv) && fromEnv > 0 ? fromEnv
+            : Number.isFinite(fromSettings) && fromSettings > 0 ? fromSettings
+                : DEFAULT_MAX_ITERATIONS;
+    return Math.min(Math.floor(candidate), MAX_ITERATIONS_CEILING);
+}
+// When the soft budget is exhausted with work still pending, keep going instead
+// of stopping. Precedence: options.autoContinue → env NEXRALL_AUTO_CONTINUE →
+// settings.autoContinue → default (on). Bounded by STALL_LIMIT and the ceiling.
+function resolveAutoContinue(optionValue, settingsRaw) {
+    if (typeof optionValue === 'boolean')
+        return optionValue;
+    const env = process.env.NEXRALL_AUTO_CONTINUE;
+    if (env === '0' || env === 'false')
+        return false;
+    if (env === '1' || env === 'true')
+        return true;
+    const s = settingsRaw.autoContinue;
+    if (typeof s === 'boolean')
+        return s;
+    return true;
+}
+// ─── Per-file write lock ──────────────────────────────────────────────────────
+// When the model emits multiple tool_use blocks in one turn (executed via
+// Promise.all), two edits to the same file race: both read the original, both
+// write their version, and the second write silently discards the first edit.
+// This lock serialises writes per absolute path to prevent that.
+const _fileLocks = new Map();
+async function withFileLock(absPath, fn) {
+    const prev = _fileLocks.get(absPath) ?? Promise.resolve();
+    let releaseLock;
+    const next = new Promise((res) => { releaseLock = res; });
+    _fileLocks.set(absPath, prev.then(() => next));
+    try {
+        await prev; // wait for any in-flight operation on this file
+        return await fn();
+    }
+    finally {
+        releaseLock();
+        // Cleanup: remove the entry once the chain is idle to avoid unbounded growth
+        if (_fileLocks.get(absPath) === next)
+            _fileLocks.delete(absPath);
+    }
+}
+// ─── Human-readable tool descriptions ────────────────────────────────────────
+function humanDescription(name, input) {
+    switch (name) {
+        case 'read_file':
+            return `Read file: ${input.path ?? '(unknown)'}`;
+        case 'write_file': {
+            const content = typeof input.content === 'string' ? input.content : '';
+            const bytes = Buffer.byteLength(content, 'utf-8');
+            return `Write file: ${input.path ?? '(unknown)'} (${bytes} bytes)`;
+        }
+        case 'list_directory':
+            return `List directory: ${input.path ?? '.'}`;
+        case 'bash':
+            return `Run: ${input.command ?? '(unknown)'}`;
+        case 'search_files': {
+            const searchType = input.type === 'filename' ? 'filename' : 'content';
+            const inPath = input.path ? ` in ${input.path}` : '';
+            return `Search ${searchType}: "${input.pattern ?? ''}"${inPath}`;
+        }
+        case 'create_directory':
+            return `Create directory: ${input.path ?? '(unknown)'}`;
+        case 'move_file':
+            return `Move file: ${input.source ?? '(unknown)'} → ${input.dest ?? '(unknown)'}`;
+        case 'copy_file':
+            return `Copy file: ${input.source ?? '(unknown)'} → ${input.destination ?? '(unknown)'}`;
+        case 'edit_file':
+            return `Edit file: ${input.path ?? '(unknown)'}`;
+        case 'multi_edit': {
+            const edits = Array.isArray(input.edits) ? input.edits : [];
+            return `Multi-edit file: ${input.path ?? '(unknown)'} (${edits.length} change${edits.length !== 1 ? 's' : ''})`;
+        }
+        case 'glob':
+            return `Glob: ${input.pattern ?? '(unknown)'}${input.path ? ` in ${input.path}` : ''}`;
+        case 'todo_write': {
+            const todos = Array.isArray(input.todos) ? input.todos : [];
+            return `Update task list (${todos.length} item${todos.length !== 1 ? 's' : ''})`;
+        }
+        case 'todo_read':
+            return 'Read task list';
+        case 'notebook_read':
+            return `Read notebook: ${input.path ?? '(unknown)'}`;
+        case 'notebook_edit': {
+            const t = input.edit_type ?? 'edit';
+            return `Notebook ${t}: ${input.path ?? '(unknown)'} cell ${input.cell_index ?? '?'}`;
+        }
+        case 'delete_file':
+            return `Delete file: ${input.path ?? '(unknown)'}`;
+        case 'bash_output':
+            return `Read background shell: ${input.shell_id ?? '(unknown)'}`;
+        case 'kill_shell':
+            return `Kill background shell: ${input.shell_id ?? '(unknown)'}`;
+        case 'fetch_url':
+            return `Fetch URL: ${input.url ?? '(unknown)'}`;
+        case 'generate_image':
+            return `Generate image → ${input.path ?? '(unknown)'}`;
+        case 'stock_photo':
+            return input.path
+                ? `Stock photo "${input.query ?? ''}" → ${input.path}`
+                : `Search stock photos: "${input.query ?? ''}"`;
+        case 'task': {
+            const desc = typeof input.description === 'string' ? input.description : '';
+            const preview = typeof input.prompt === 'string' ? input.prompt.slice(0, 60) : '';
+            return `Sub-task: ${desc || preview}${!desc && preview.length === 60 ? '…' : ''}`;
+        }
+        case 'get_diagnostics':
+            return input.path ? `Get diagnostics: ${input.path}` : 'Get workspace diagnostics';
+        case 'go_to_definition':
+            return `Go to definition: ${input.path ?? ''}:${input.line ?? ''}:${input.character ?? ''}`;
+        case 'find_references':
+            return `Find references: ${input.path ?? ''}:${input.line ?? ''}:${input.character ?? ''}`;
+        case 'get_symbols':
+            return `Get symbols: ${input.path ?? '(unknown)'}`;
+        case 'get_workspace_symbols':
+            return `Search symbols: "${input.query ?? ''}"`;
+        case 'get_hover':
+            return `Get hover info: ${input.path ?? ''}:${input.line ?? ''}:${input.character ?? ''}`;
+        case 'open_in_browser':
+            return `Open in browser: ${input.url ?? '(unknown)'}`;
+        default:
+            return `Use tool: ${name}`;
+    }
+}
+// ─── Sub-task runner ──────────────────────────────────────────────────────────
+const MAX_TASK_DEPTH = 2; // main agent (0) can spawn sub-agents (1) — sub-agents cannot spawn further
+let _subTaskCounter = 0; // unique per-process id → per-sub-agent todo scope
+async function runSubTask(input, options, agentTypes) {
+    const prompt = typeof input.prompt === 'string' ? input.prompt.trim() : '';
+    if (!prompt)
+        return { error: 'task tool requires a non-empty prompt' };
+    const depth = options._depth ?? 0;
+    if (depth >= MAX_TASK_DEPTH) {
+        return { error: `Sub-task depth limit (${MAX_TASK_DEPTH}) reached — sub-agents cannot spawn further sub-agents.` };
+    }
+    // Resolve an optional custom agent type (subagent_type).
+    const requestedType = typeof input.subagent_type === 'string' ? input.subagent_type : '';
+    const agent = (0, agentTypes_1.findAgentType)(agentTypes, requestedType);
+    if (requestedType && !agent) {
+        const known = agentTypes.map((a) => a.name).join(', ') || '(none defined)';
+        return { error: `Unknown subagent_type "${requestedType}". Available types: ${known}.` };
+    }
+    // A custom agent's persona is delivered through the project-instructions
+    // channel (authoritative in the system prompt), layered above the project's
+    // own nexrall.md so it keeps project conventions.
+    const subNexrallMd = agent
+        ? `# Sub-agent role: ${agent.name}\n${agent.prompt}` +
+            (options.nexrallMd ? `\n\n---\n\n${options.nexrallMd}` : '')
+        : options.nexrallMd;
+    // Optional tool allowlist — deny anything outside it for this sub-agent.
+    const allowed = agent?.tools ? new Set(agent.tools) : null;
+    const gatedPermission = async (req) => {
+        if (allowed && !allowed.has(req.tool))
+            return false;
+        return options.requestPermission(req);
+    };
+    const subMessages = [
+        { role: 'user', content: [{ type: 'text', text: prompt }] },
+    ];
+    try {
+        const result = await runAgentLoop(subMessages, {
+            ...options,
+            _depth: depth + 1,
+            _agentScope: `sub_${++_subTaskCounter}`, // isolated todo store per sub-agent
+            editorContext: null, // fresh isolated context for sub-agent
+            model: agent?.model ?? options.model,
+            nexrallMd: subNexrallMd,
+            requestPermission: gatedPermission,
+            onText: () => { }, // sub-agent text is returned as the tool result, not streamed live
+            // Forward tool events with isSubTask=true so the UI can render a badge
+            // instead of prepending "[sub-task]" to the tool name (which caused double-prefix
+            // when the name was already labelled, and mixed display concerns into the data layer).
+            onToolUse: (n, i) => options.onToolUse(n, i, true),
+            onToolResult: (n, r) => options.onToolResult(n, r, true),
+            // Forward thinking so the UI shows the indicator while sub-agent reasons
+            onThinking: (text) => options.onThinking?.(text),
+            onThinkingDelta: (text) => options.onThinkingDelta?.(text),
+            onThinkingProgress: (tok) => options.onThinkingProgress?.(tok),
+        });
+        // Extract final assistant text as the task output
+        const lastAssistant = [...result].reverse().find((m) => m.role === 'assistant');
+        const text = (lastAssistant?.content ?? [])
+            .filter((b) => b.type === 'text')
+            .map((b) => b.text)
+            .join('')
+            .trim();
+        return { output: text || '(sub-task completed with no text output)' };
+    }
+    catch (err) {
+        return { error: `Sub-task failed: ${err.message}` };
+    }
+}
+// ─── Auto-compact ─────────────────────────────────────────────────────────────
+//
+// When the conversation's prompt size approaches the model's context window,
+// summarise the older portion automatically (Claude-Code style) instead of
+// letting the request fail or forcing the user to run /compact by hand.
+//
+// Compaction only happens at a turn boundary (top of the loop, before the next
+// streamChat) and only cuts at a "safe" user message — one with no tool_result
+// blocks — so tool_use/tool_result pairing is never broken.
+const MODEL_CONTEXT_TOKENS = {
+    turbo: 200000,
+    pro: 200000,
+    ultra: 1000000,
+};
+const AUTO_COMPACT_THRESHOLD = 0.8; // compact when prompt > 80% of the window
+const COMPACT_KEEP_MIN = 6; // always keep at least the last N messages verbatim
+function resolveAutoCompact(fromOptions, rawSettings) {
+    if (typeof fromOptions === 'boolean')
+        return fromOptions;
+    const env = (process.env.NEXRALL_AUTO_COMPACT ?? '').toLowerCase();
+    if (env === '0' || env === 'false' || env === 'off')
+        return false;
+    if (env === '1' || env === 'true' || env === 'on')
+        return true;
+    const s = rawSettings?.autoCompact;
+    if (typeof s === 'boolean')
+        return s;
+    return true;
+}
+/** Find the latest index ≤ maxIdx where history can be cut safely (user msg, no tool_results). */
+function findSafeCutIndex(messages, maxIdx) {
+    for (let i = Math.min(maxIdx, messages.length - 1); i > 0; i--) {
+        const m = messages[i];
+        if (m.role !== 'user')
+            continue;
+        const hasToolResult = m.content.some((b) => b.type === 'tool_result');
+        if (!hasToolResult)
+            return i;
+    }
+    return -1;
+}
+/** Render messages to a plain-text transcript for the summariser (tool noise truncated). */
+function transcriptOf(messages) {
+    const parts = [];
+    for (const m of messages) {
+        for (const b of m.content) {
+            if (b.type === 'text' && b.text) {
+                parts.push(`${m.role.toUpperCase()}: ${b.text.slice(0, 2000)}`);
+            }
+            else if (b.type === 'tool_use') {
+                parts.push(`${m.role.toUpperCase()} [tool: ${b.name}]: ${JSON.stringify(b.input ?? {}).slice(0, 400)}`);
+            }
+            else if (b.type === 'tool_result') {
+                parts.push(`TOOL RESULT: ${String(b.content ?? '').slice(0, 600)}`);
+            }
+        }
+    }
+    return parts.join('\n');
+}
+/**
+ * Compact `messages` in place: summarise everything before a safe cut point and
+ * replace it with a summary preamble. Returns true if compaction happened.
+ */
+async function autoCompactMessages(messages, options) {
+    const cut = findSafeCutIndex(messages, messages.length - COMPACT_KEEP_MIN);
+    if (cut < 2)
+        return false; // nothing meaningful to fold
+    const toSummarize = messages.slice(0, cut);
+    const kept = messages.slice(cut);
+    const summaryPrompt = `Summarize this coding-session transcript into concise bullet points the assistant needs to continue the work: ` +
+        `key decisions, files changed (and how), commands run, unresolved problems, and user preferences. Max 400 words.\n\n` +
+        transcriptOf(toSummarize);
+    let summary = '';
+    try {
+        const reply = await (0, client_1.streamChat)([{ role: 'user', content: [{ type: 'text', text: summaryPrompt }] }], {
+            model: options.model ?? 'turbo',
+            mode: 'ask', // summariser must not call tools; ask-mode discourages action
+            env: options.env,
+            clientType: options.clientType,
+            abortSignal: options.abortSignal,
+        }, () => { });
+        summary = reply.content
+            .filter((b) => b.type === 'text')
+            .map((b) => b.text ?? '')
+            .join('')
+            .trim();
+    }
+    catch {
+        return false; // summarisation failed — leave history as is, the turn may still fit
+    }
+    if (!summary)
+        return false;
+    messages.splice(0, cut, { role: 'user', content: [{ type: 'text', text: `[Auto-compacted ${toSummarize.length} earlier messages]\n\nSummary of the earlier conversation:\n${summary}` }] }, { role: 'assistant', content: [{ type: 'text', text: 'Understood — I have the summary of our earlier work and will continue from there.' }] });
+    // `kept` follows automatically since splice only replaced the head.
+    void kept;
+    return true;
+}
+// ─── Agent Loop ───────────────────────────────────────────────────────────────
+async function runAgentLoop(initialMessages, options) {
+    const messages = [...initialMessages];
+    const model = options.model ?? 'turbo';
+    const hooks = loadHooks(options.workDir);
+    const depth = options._depth ?? 0;
+    const agentScope = options._agentScope ?? 'root';
+    // Discover custom sub-agent types. Only the top-level agent is told the
+    // catalogue (sub-agents can't spawn further), but every level resolves types.
+    const agentTypes = (0, agentTypes_1.loadAgentTypes)(options.workDir);
+    const agentsCatalogue = depth === 0 ? (0, agentTypes_1.summariseAgents)(agentTypes) : '';
+    // Optional OS-level bash sandbox (opt-in via settings.json "sandbox").
+    const settings = (0, rules_1.loadSettings)(options.workDir);
+    const sandboxCfg = (0, sandbox_1.parseSandboxConfig)(settings.raw.sandbox) ?? undefined;
+    // Soft iteration budget + optional auto-continue past it (see resolvers above).
+    const maxIterations = resolveMaxIterations(options.maxIterations, settings.raw);
+    const autoContinue = resolveAutoContinue(options.autoContinue, settings.raw);
+    const autoCompact = resolveAutoCompact(options.autoCompact, settings.raw);
+    const contextWindow = MODEL_CONTEXT_TOKENS[model] ?? 200000;
+    // Live prompt-size estimate, updated from usage events after every stream.
+    let lastPromptTokens = 0;
+    let compacting = false; // re-entrancy guard — compaction itself calls streamChat
+    // Absolute hard stop: auto-continue extends the budget in maxIterations-sized
+    // segments up to this ceiling; without auto-continue, the soft budget IS the cap.
+    const hardCap = autoContinue ? Math.max(maxIterations, MAX_ITERATIONS_CEILING) : maxIterations;
+    // NOTE: we deliberately do NOT call process.chdir(options.workDir) here.
+    // process.cwd() is global process state — mutating it from concurrent sub-agent
+    // coroutines (task tool runs multiple sub-agents via Promise.all) causes a race
+    // condition where one sub-agent's chdir overwrites another's, making every tool
+    // that falls back to process.cwd() resolve paths against the wrong directory.
+    // workDir is now threaded explicitly through executeTool → resolvePath instead.
+    // Distinguish a clean finish (model produced a final answer) from hitting the
+    // iteration backstop, so we can tell the user what happened rather than
+    // silently returning a half-done task.
+    let completedCleanly = false;
+    let stalledOut = false; // tripped the runaway guard (all-failed rounds)
+    let consecutiveErrorRounds = 0; // rounds where every tool call errored
+    let budget = maxIterations; // extended by auto-continue, capped at hardCap
+    let iteration = 0;
+    try {
+        for (; iteration < budget; iteration++) {
+            if (options.abortSignal?.aborted)
+                break;
+            // Auto-compact: if the last request's prompt crossed the threshold,
+            // summarise older history before the next stream so we never hit the
+            // context-window wall mid-task. Runs at a turn boundary only.
+            if (autoCompact && !compacting && lastPromptTokens > contextWindow * AUTO_COMPACT_THRESHOLD && messages.length > COMPACT_KEEP_MIN + 2) {
+                compacting = true;
+                try {
+                    const did = await autoCompactMessages(messages, options);
+                    if (did) {
+                        lastPromptTokens = 0; // stale — next usage event refreshes it
+                        options.onText(`\n\u267b\ufe0f Auto-compacted earlier conversation to stay within the context window.\n`);
+                    }
+                }
+                finally {
+                    compacting = false;
+                }
+            }
+            // When auto-continue is off, nudge the model to wrap up just before the hard
+            // cap so it isn't cut off mid-task. (With auto-continue on we WANT it to keep
+            // going, so no wrap-up nudge.)
+            if (!autoContinue && iteration === budget - 5 && budget > 5) {
+                options.onText(`\n⚠️ Approaching the ${budget}-step limit (step ${iteration + 1}). Please wrap up and summarise what has been done.\n`);
+            }
+            // Collect tool_use blocks emitted during this stream
+            const pendingToolUse = [];
+            // Build SSE event handler
+            const onEvent = (event) => {
+                switch (event.type) {
+                    case 'text':
+                        options.onText(event.text);
+                        break;
+                    case 'thinking':
+                        options.onThinking?.(event.text);
+                        break;
+                    case 'thinking_delta':
+                        options.onThinkingDelta?.(event.text);
+                        break;
+                    case 'thinking_progress':
+                        options.onThinkingProgress?.(event.tokens);
+                        break;
+                    case 'tool_use':
+                        // Collect tool use blocks — they may arrive incrementally
+                        // We use message_complete to finalize them, so just track here
+                        pendingToolUse.push({
+                            type: 'tool_use',
+                            id: event.id,
+                            name: event.name,
+                            input: event.input,
+                        });
+                        break;
+                    case 'usage':
+                        lastPromptTokens =
+                            (event.usage.input_tokens ?? 0) +
+                                (event.usage.cache_creation_input_tokens ?? 0) +
+                                (event.usage.cache_read_input_tokens ?? 0);
+                        options.onUsage(event.usage);
+                        break;
+                    case 'message_complete':
+                        // The complete message is returned from streamChat, we handle it below
+                        break;
+                    case 'done':
+                    case 'error':
+                        break;
+                }
+            };
+            // 1. Stream from the API
+            let assistantMessage;
+            try {
+                assistantMessage = await (0, client_1.streamChat)(messages, {
+                    model,
+                    mode: options.mode,
+                    effort: options.effort,
+                    env: options.env,
+                    editorContext: options.editorContext,
+                    nexrallMd: options.nexrallMd,
+                    clientType: options.clientType,
+                    abortSignal: options.abortSignal,
+                    extraTools: options.mcpManager?.getAnthropicTools(),
+                    agents: agentsCatalogue || undefined,
+                }, onEvent);
+            }
+            catch (err) {
+                if (options.abortSignal?.aborted || err.name === 'AbortError')
+                    break;
+                runSimpleHooks(hooks.OnError, options.workDir);
+                throw new Error(`Stream failed: ${err.message}`);
+            }
+            if (options.abortSignal?.aborted)
+                break;
+            // 2. Strip thinking blocks — API rejects them in message history
+            assistantMessage.content = assistantMessage.content.filter((b) => b.type !== 'thinking' && b.type !== 'redacted_thinking');
+            // If the model returned nothing usable (e.g. thinking-only, then stopped), the
+            // stripped content is empty. Do NOT push an empty assistant turn into history — it
+            // would be sent back on the next request and either error or force a placeholder,
+            // and combined with a folded follow-up it leaks an empty turn to the model. Treat
+            // it as a no-op step: fold any queued input and continue, otherwise end cleanly.
+            if (assistantMessage.content.length === 0) {
+                const queued = options.takePendingInput?.() ?? [];
+                if (queued.length) {
+                    const text = queued.join('\n\n');
+                    queued.forEach((q) => options.onInjectedInput?.(q));
+                    messages.push({ role: 'user', content: [{ type: 'text', text }] });
+                    continue;
+                }
+                runSimpleHooks(hooks.PostMessageComplete, options.workDir);
+                completedCleanly = true;
+                break;
+            }
+            messages.push(assistantMessage);
+            // 3. Collect tool_use blocks from the completed message.
+            //    Server-side tools (e.g. web_search_20260209) are executed by Anthropic and their
+            //    tool_result blocks appear in the SAME assistant message.  We must skip those —
+            //    sending a second tool_result for them would confuse the API.
+            const serverSideResultIds = new Set(assistantMessage.content
+                .filter(b => b.type === 'tool_result')
+                .map(b => b.tool_use_id)
+                .filter((id) => !!id));
+            const toolUseBlocks = assistantMessage.content.filter((block) => block.type === 'tool_use' && !serverSideResultIds.has(block.id));
+            // 4. If no tool use → agent produced a final text response.
+            //    But if the user queued a follow-up while we were working, fold it in as the
+            //    next user turn and keep going instead of ending (Claude-Code style).
+            if (toolUseBlocks.length === 0) {
+                const queued = options.takePendingInput?.() ?? [];
+                if (queued.length) {
+                    const text = queued.join('\n\n');
+                    queued.forEach((q) => options.onInjectedInput?.(q));
+                    messages.push({ role: 'user', content: [{ type: 'text', text }] });
+                    continue;
+                }
+                runSimpleHooks(hooks.PostMessageComplete, options.workDir);
+                completedCleanly = true;
+                break;
+            }
+            // 5. Execute all tool uses in parallel
+            const toolResults = await Promise.all(toolUseBlocks.map(async (block) => {
+                const { id, name, input } = block;
+                // Notify caller about pending tool use
+                options.onToolUse(name, input);
+                // Request permission
+                const description = humanDescription(name, input);
+                let result;
+                let permitted;
+                try {
+                    permitted = await options.requestPermission({ tool: name, input, description });
+                }
+                catch {
+                    permitted = false;
+                }
+                if (!permitted) {
+                    result = { error: 'Permission denied by user' };
+                }
+                else if (name === 'task') {
+                    result = await runSubTask(input, options, agentTypes);
+                }
+                else {
+                    const pre = runToolHooks(hooks.PreToolUse, 'PreToolUse', name, input, options.workDir);
+                    if (pre.block) {
+                        result = { error: `Blocked by PreToolUse hook: ${pre.reason}` };
+                    }
+                    else {
+                        try {
+                            // 1. Try platform-specific tools (e.g. VS Code semantic tools)
+                            const external = options.executeExternalTool
+                                ? await options.executeExternalTool(name, input)
+                                : null;
+                            if (external !== null && external !== undefined) {
+                                result = external;
+                                // 2. Try MCP tools (serverName__toolName)
+                            }
+                            else if (options.mcpManager?.isMcpTool(name)) {
+                                const mcpOutput = await options.mcpManager.callTool(name, input);
+                                result = { output: mcpOutput ?? '' };
+                                // 3. Fall through to built-in executor
+                            }
+                            else {
+                                // Snapshot pre-mutation state so the user can /rewind this turn.
+                                options.checkpointManager?.recordBeforeMutation(name, input);
+                                // Serialise writes to the same file: if the model emits two
+                                // edit_file/write_file calls for the same path in one turn
+                                // (executed via Promise.all), the second would overwrite the
+                                // first. withFileLock queues them so they apply sequentially.
+                                const WRITE_TOOLS = new Set(['write_file', 'edit_file', 'multi_edit', 'delete_file', 'move_file', 'copy_file', 'notebook_edit']);
+                                if (WRITE_TOOLS.has(name)) {
+                                    const targetPath = (typeof input.path === 'string' ? input.path : typeof input.source === 'string' ? input.source : '');
+                                    const absTarget = targetPath && options.workDir ? path.resolve(options.workDir, targetPath) : targetPath;
+                                    result = await withFileLock(absTarget || name, () => (0, executor_1.executeTool)(name, input, options.abortSignal, sandboxCfg, options.workDir, agentScope));
+                                }
+                                else {
+                                    result = await (0, executor_1.executeTool)(name, input, options.abortSignal, sandboxCfg, options.workDir, agentScope);
+                                }
+                            }
+                        }
+                        catch (err) {
+                            result = { error: `Tool execution failed: ${err.message}` };
+                        }
+                        // PostToolUse can inject context for the model or flag a problem.
+                        const post = runToolHooks(hooks.PostToolUse, 'PostToolUse', name, input, options.workDir, result);
+                        const injected = [pre.context, post.context].filter(Boolean).join('\n');
+                        if (injected) {
+                            if (result.error !== undefined)
+                                result.error = `${result.error}\n\n[hook] ${injected}`;
+                            else
+                                result.output = `${result.output ?? ''}\n\n[hook] ${injected}`;
+                        }
+                        if (post.block) {
+                            // e.g. a lint/test hook failed — surface it as an error so the model fixes it.
+                            result.error = `${result.error ? result.error + '\n' : ''}PostToolUse hook flagged: ${post.reason}`;
+                        }
+                    }
+                }
+                // Notify caller about result
+                options.onToolResult(name, result);
+                return { block: { ...block, id }, result };
+            }));
+            // 6. Build tool_result message and append to history
+            const toolResultBlocks = toolResults.map(({ block, result }) => ({
+                type: 'tool_result',
+                tool_use_id: block.id,
+                content: result.error
+                    ? `Error: ${result.error}`
+                    : result.output ?? '',
+                is_error: result.error !== undefined,
+            }));
+            // Fold any follow-up the user queued mid-task into THIS user turn (alongside the
+            // tool results) so the agent sees it on the very next step — not after the whole
+            // task finishes. Appending a text block to the tool_result user message keeps the
+            // required user/assistant alternation intact.
+            const toolResultContent = [...toolResultBlocks];
+            const queuedMid = options.takePendingInput?.() ?? [];
+            if (queuedMid.length) {
+                const text = queuedMid.join('\n\n');
+                queuedMid.forEach((q) => options.onInjectedInput?.(q));
+                toolResultContent.push({ type: 'text', text });
+            }
+            const toolResultMessage = {
+                role: 'user',
+                content: toolResultContent,
+            };
+            messages.push(toolResultMessage);
+            // Runaway guard: if every tool call in this round failed, count it. Enough
+            // consecutive all-failed rounds (e.g. a command that always errors, or the
+            // user denying every permission) means we're stuck — stop instead of
+            // burning the whole budget spinning.
+            const allErrored = toolResults.length > 0 && toolResults.every(({ result }) => result.error !== undefined);
+            consecutiveErrorRounds = allErrored ? consecutiveErrorRounds + 1 : 0;
+            if (consecutiveErrorRounds >= STALL_LIMIT) {
+                stalledOut = true;
+                break;
+            }
+            // Auto-continue: about to exhaust the current budget but the model is still
+            // calling tools (task unfinished) and we're under the ceiling → extend the
+            // budget by another segment and keep going, so the agent finishes on its own
+            // without the user having to type "continue". History stays valid (ends on a
+            // tool_result turn), so no API error on the next step.
+            if (autoContinue && iteration + 1 >= budget && budget < hardCap) {
+                budget = Math.min(budget + maxIterations, hardCap);
+                options.onText(`\n🔄 Auto-continuing (extended to ${budget} steps) — the task isn't finished yet.\n`);
+            }
+            // Loop back to step 1
+        }
+        // Explain why we stopped when it wasn't a clean finish or a user abort, so a
+        // long run never just goes silent. History ends on a tool_result turn, so
+        // "continue" resumes exactly where it left off.
+        if (!options.abortSignal?.aborted && !completedCleanly) {
+            if (stalledOut) {
+                options.onText(`\n🛑 Stopped: the last ${STALL_LIMIT} tool rounds all failed, so the agent looked stuck. ` +
+                    `Fix the underlying error (or grant the needed permission) and send "continue".\n`);
+            }
+            else if (iteration >= budget) {
+                options.onText(`\n⏸️ Stopped at the ${budget}-step safety limit — the task may be incomplete. ` +
+                    `Send "continue" to resume, or raise the limit via "maxIterations" in .nexrall/settings.json ` +
+                    `(or the NEXRALL_MAX_ITERATIONS env var). Auto-continue can be disabled with "autoContinue": false.\n`);
+            }
+        }
+    }
+    finally {
+        runSimpleHooks(hooks.OnStop, options.workDir);
+    }
+    return messages;
+}
+//# sourceMappingURL=loop.js.map