@element47/ag 4.4.0

package/dist/core/agent.js

@@ -0,0 +1,711 @@
+import { readdirSync, statSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { execFileSync } from 'node:child_process';
+import { C } from './colors.js';
+import { loadContext, loadHistory, appendHistory, getStats, clearProject, clearAll, paths, saveGlobalMemory, saveProjectMemory, savePlan, appendPlan, setActivePlan, getActivePlanName, loadGlobalMemory, loadProjectMemory, loadPlan, loadPlanByName, listPlans } from '../memory/memory.js';
+import { bashToolFactory } from '../tools/bash.js';
+import { memoryTool } from '../tools/memory.js';
+import { planTool } from '../tools/plan.js';
+import { gitTool } from '../tools/git.js';
+import { skillTool } from '../tools/skill.js';
+import { webTool } from '../tools/web.js';
+import { grepTool } from '../tools/grep.js';
+import { fileTool } from '../tools/file.js';
+import { discoverSkills, buildSkillCatalog, getAlwaysOnContent, loadSkillTools } from './skills.js';
+import { ContextTracker } from './context.js';
+export const MAX_ITERATIONS_REACHED = '[Max iterations reached]';
+const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+function startSpinner(label) {
+    if (!process.stderr.isTTY) {
+        // Non-TTY fallback: static status line
+        process.stderr.write(`  ... ${label}\n`);
+        return () => { };
+    }
+    let i = 0;
+    process.stderr.write(`  ${C.dim}${SPINNER_FRAMES[0]} ${label}${C.reset}\n`);
+    const id = setInterval(() => {
+        process.stderr.write(`\x1b[A\x1b[K  ${C.dim}${SPINNER_FRAMES[i++ % SPINNER_FRAMES.length]} ${label}${C.reset}\n`);
+    }, 80);
+    return () => {
+        clearInterval(id);
+        process.stderr.write('\x1b[A\x1b[K');
+    };
+}
+const MAX_MESSAGES = 200;
+const COMPACT_THRESHOLD = 0.9;
+const MAX_TOOL_RESULT_CHARS = 8192;
+const TRUNCATION_HEAD_LINES = 50;
+const TRUNCATION_TAIL_LINES = 50;
+const COMPACT_HEAD_KEEP = 2;
+const COMPACT_TAIL_KEEP = 10;
+const COMPACT_MSG_CHARS = 500;
+const COMPACT_TOTAL_CHARS = 50000;
+const COMPACTION_PROMPT = `Summarize this conversation between a user and a coding assistant. Extract essential context needed to continue working.
+
+You MUST preserve exactly:
+- All file paths that were read, edited, or created (full paths, not abbreviated)
+- All error messages and their causes
+- Decisions made and their rationale
+- Current task: what was asked, what's done, what remains
+- Any user preferences or constraints mentioned
+
+Format as structured bullet points. Be concise but never drop paths, error details, or decision rationale — these are critical for the assistant to continue without re-reading files or re-discovering errors.`;
+export function getEnvironmentContext(cwd) {
+    const lines = ['# Environment'];
+    lines.push(`Date: ${new Date().toISOString().slice(0, 10)}`);
+    lines.push(`OS: ${process.platform}`);
+    lines.push(`CWD: ${cwd}`);
+    // Git info
+    if (existsSync(join(cwd, '.git'))) {
+        try {
+            const branch = execFileSync('git', ['rev-parse', '--abbrev-ref', 'HEAD'], { cwd, encoding: 'utf-8', timeout: 3000 }).trim();
+            lines.push(`Git branch: ${branch}`);
+            const dirty = execFileSync('git', ['status', '--porcelain'], { cwd, encoding: 'utf-8', timeout: 3000 }).trim();
+            if (dirty) {
+                const count = dirty.split('\n').length;
+                lines.push(`Git status: ${count} changed file(s)`);
+            }
+        }
+        catch { /* not a git repo or git not installed */ }
+    }
+    // Detect stack from config files
+    const detectedStack = [];
+    const stackHints = [
+        ['package.json', 'Node.js'],
+        ['tsconfig.json', 'TypeScript'],
+        ['Cargo.toml', 'Rust'],
+        ['go.mod', 'Go'],
+        ['pyproject.toml', 'Python'],
+        ['requirements.txt', 'Python'],
+        ['Gemfile', 'Ruby'],
+        ['pom.xml', 'Java/Maven'],
+        ['build.gradle', 'Java/Gradle'],
+    ];
+    for (const [file, stack] of stackHints) {
+        if (existsSync(join(cwd, file)))
+            detectedStack.push(stack);
+    }
+    if (detectedStack.length > 0)
+        lines.push(`Stack: ${detectedStack.join(', ')}`);
+    return lines.join('\n');
+}
+/** Tool actions that are read-only and never need confirmation */
+const READ_ONLY_CALLS = {
+    grep: true, // all grep actions are read-only
+    memory: true, // saving memory is safe
+    plan: true, // managing plans is safe
+    skill: true, // activating skills is safe
+    file: new Set(['read', 'list']), // only read/list are safe
+    git: new Set(['status']), // only status is safe
+    web: new Set(['search']), // search is safe, fetch needs confirm
+};
+export function isReadOnlyToolCall(toolName, args) {
+    const rule = READ_ONLY_CALLS[toolName];
+    if (rule === true)
+        return true;
+    if (rule instanceof Set)
+        return rule.has(args.action);
+    return false;
+}
+export function truncateToolResult(result) {
+    if (result.length <= MAX_TOOL_RESULT_CHARS)
+        return result;
+    const lines = result.split('\n');
+    if (lines.length <= TRUNCATION_HEAD_LINES + TRUNCATION_TAIL_LINES)
+        return result;
+    const head = lines.slice(0, TRUNCATION_HEAD_LINES);
+    const tail = lines.slice(-TRUNCATION_TAIL_LINES);
+    const omitted = lines.length - TRUNCATION_HEAD_LINES - TRUNCATION_TAIL_LINES;
+    return [...head, `\n... [${omitted} lines truncated] ...\n`, ...tail].join('\n');
+}
+export class Agent {
+    apiKey;
+    model;
+    baseURL;
+    baseSystemPrompt;
+    maxIterations;
+    tools;
+    cwd;
+    messages = [];
+    allSkills = [];
+    activeSkillContent = [];
+    cachedContext = '';
+    cachedCatalog = '';
+    cachedAlwaysOn = '';
+    builtinToolNames = new Set();
+    contextTracker;
+    compactionInProgress = false;
+    confirmToolCall;
+    constructor(config = {}) {
+        this.apiKey = config.apiKey || process.env.OPENROUTER_API_KEY || '';
+        if (!this.apiKey)
+            throw new Error('No API key. Set OPENROUTER_API_KEY, pass -k, or run `ag` interactively to configure.');
+        this.model = config.model || 'anthropic/claude-sonnet-4.6';
+        this.baseURL = config.baseURL || 'https://openrouter.ai/api/v1';
+        this.baseSystemPrompt = config.systemPrompt || `You are ag, a coding agent that completes tasks by calling tools. You work autonomously — never ask the user for information you can find yourself.
+
+# Tool use
+- To read files, use file(action=read). Do NOT use bash with cat, head, or tail.
+- To edit files, use file(action=edit). Do NOT use bash with sed or awk.
+- To create files, use file(action=write). Do NOT use bash with echo or heredocs.
+- To search file contents, use grep(action=search). Do NOT use bash with grep or rg.
+- To find files by name/pattern, use grep(action=find). Do NOT use bash with find or ls.
+- To browse directories, use file(action=list). Do NOT use bash with ls or tree.
+- Use bash only for running commands: tests, builds, installs, servers, and system operations.
+- Use git for all version control operations — not bash with git commands.
+- If the user mentions a file vaguely, search for it with grep(action=find) before anything else.
+
+# Working with code
+- Always read a file before editing it. Never propose changes to code you haven't read.
+- Do not create new files unless necessary — prefer editing existing files.
+- Do what was asked, nothing more. Don't add features, refactor surrounding code, add comments, or make "improvements" beyond the request.
+- Don't add error handling or validation for scenarios that can't happen. Trust internal code.
+- Be careful not to introduce security vulnerabilities (XSS, SQL injection, command injection). If you notice insecure code you wrote, fix it immediately.
+
+# Error recovery
+- If a tool fails, diagnose why before switching tactics. Read the error, check your assumptions, try a focused fix.
+- Don't retry the identical action. Don't abandon a viable approach after a single failure either.
+- If file(action=edit) fails with "not found", re-read the file to verify exact content.
+- If bash returns a non-zero exit code, read the stderr output to understand the failure.
+- Ask the user only when genuinely stuck after investigation, not as a first response to friction.
+
+# Git workflow
+- Read the diff before committing. Write concise commit messages that explain why, not what.
+- Never amend commits or force-push without the user asking.
+- Never commit files that contain secrets (.env, credentials, keys).
+
+# Output
+- Be concise. Short responses, no filler, no trailing summaries of what you just did.
+- When referencing code, include the file path and relevant context.
+- Only use markdown formatting when it aids clarity.
+
+# Verification
+- After making changes, verify they work: run tests, check for syntax errors, or start the dev server as appropriate.
+- If a task involves multiple steps, verify each step before proceeding to the next.
+
+# Tools available
+- file(read/list/write/edit) — view, browse, create, and edit files
+- grep(find) — locate files by glob · grep(search) — search content by regex
+- bash — run shell commands, tests, installs, builds
+- git — status, branch, commit, push
+- memory(save) — persist facts across sessions (global or project tier)
+- plan — create and manage multi-step task plans
+- web(fetch/search) — fetch pages or search the web
+- skill — activate a skill by name`;
+        this.maxIterations = config.maxIterations || 25;
+        this.cwd = config.cwd || process.cwd();
+        this.confirmToolCall = config.confirmToolCall ?? null;
+        // Discover skills
+        this.allSkills = discoverSkills(this.cwd);
+        // Register built-in tools
+        this.tools = new Map();
+        this.addTool(bashToolFactory(this.cwd));
+        this.addTool(memoryTool(this.cwd));
+        this.addTool(planTool(this.cwd));
+        this.addTool(gitTool(this.cwd));
+        this.addTool(grepTool(this.cwd));
+        this.addTool(fileTool(this.cwd));
+        this.addTool(webTool());
+        if (this.allSkills.length > 0)
+            this.addTool(skillTool(this));
+        this.builtinToolNames = new Set(this.tools.keys());
+        for (const t of config.extraTools ?? [])
+            this.addTool(t);
+        // Context window tracking
+        this.contextTracker = new ContextTracker(this.model);
+        // Cache context and skill catalog (invalidated on skill activation/refresh)
+        this.refreshCache();
+        // Load recent conversation history for continuity
+        this.messages = loadHistory(this.cwd);
+    }
+    addTool(tool) {
+        const name = tool.function.name;
+        if (this.builtinToolNames.size > 0 && this.builtinToolNames.has(name)) {
+            process.stderr.write(`${C.yellow}Warning: tool "${name}" overwrites built-in tool${C.reset}\n`);
+        }
+        this.tools.set(name, tool);
+    }
+    refreshCache() {
+        this.cachedContext = loadContext(this.cwd);
+        this.cachedCatalog = buildSkillCatalog(this.allSkills);
+        this.cachedAlwaysOn = getAlwaysOnContent(this.allSkills);
+    }
+    getProjectListing() {
+        const MAX_ENTRIES = 30;
+        const IGNORE = new Set(['.git', 'node_modules', 'dist', 'build', '.next', '.cache', '__pycache__']);
+        try {
+            const entries = readdirSync(this.cwd, { withFileTypes: true });
+            const lines = [];
+            for (const e of entries) {
+                if (lines.length >= MAX_ENTRIES) {
+                    lines.push(`  ... (${entries.length - MAX_ENTRIES} more)`);
+                    break;
+                }
+                if (IGNORE.has(e.name))
+                    continue;
+                if (e.name.startsWith('.') && e.name !== '.')
+                    continue;
+                if (e.isDirectory()) {
+                    lines.push(`  [dir] ${e.name}/`);
+                }
+                else {
+                    try {
+                        const s = statSync(join(this.cwd, e.name));
+                        const kb = (s.size / 1024).toFixed(1);
+                        lines.push(`  ${e.name} (${kb}KB)`);
+                    }
+                    catch {
+                        lines.push(`  ${e.name}`);
+                    }
+                }
+            }
+            return lines.length > 0 ? `Project files (${this.cwd}):\n${lines.join('\n')}` : '';
+        }
+        catch {
+            return '';
+        }
+    }
+    get systemPrompt() {
+        const parts = [this.baseSystemPrompt];
+        parts.push(getEnvironmentContext(this.cwd));
+        const listing = this.getProjectListing();
+        if (listing)
+            parts.push(listing);
+        if (this.cachedContext)
+            parts.push(this.cachedContext);
+        if (this.cachedCatalog)
+            parts.push(this.cachedCatalog);
+        if (this.cachedAlwaysOn)
+            parts.push(this.cachedAlwaysOn);
+        if (this.activeSkillContent.length > 0) {
+            parts.push(this.activeSkillContent.join('\n\n'));
+        }
+        return parts.join('\n\n');
+    }
+    async activateSkill(name) {
+        const skill = this.allSkills.find(s => s.name === name);
+        if (!skill)
+            return `Skill "${name}" not found. Available: ${this.allSkills.map(s => s.name).join(', ')}`;
+        if (this.activeSkillContent.some(c => c.includes(`name="${name}"`))) {
+            return `Skill "${name}" is already active.`;
+        }
+        this.activeSkillContent.push(`<skill name="${name}">\n${skill.content}\n</skill>`);
+        this.refreshCache();
+        // Load tools if skill has them
+        if (skill.hasTools) {
+            const tools = await loadSkillTools(skill.dir);
+            for (const t of tools)
+                this.addTool(t);
+            if (tools.length > 0) {
+                return `Skill "${name}" activated with ${tools.length} tool(s): ${tools.map(t => t.function.name).join(', ')}`;
+            }
+        }
+        return `Skill "${name}" activated. Instructions loaded.`;
+    }
+    async compactConversation() {
+        const minMessages = COMPACT_HEAD_KEEP + COMPACT_TAIL_KEEP + 4;
+        if (this.messages.length <= minMessages)
+            return;
+        const head = this.messages.slice(0, COMPACT_HEAD_KEEP);
+        const middle = this.messages.slice(COMPACT_HEAD_KEEP, -COMPACT_TAIL_KEEP);
+        const tail = this.messages.slice(-COMPACT_TAIL_KEEP);
+        // Format middle messages for summarization, capping total size
+        let totalChars = 0;
+        const formatted = [];
+        for (const m of middle) {
+            let line;
+            if (m.tool_calls?.length) {
+                const names = m.tool_calls.map(tc => tc.function.name).join(', ');
+                line = `[assistant]: (tool call: ${names})`;
+            }
+            else if (m.role === 'tool') {
+                line = `[tool result]: ${(m.content || '').slice(0, COMPACT_MSG_CHARS)}`;
+            }
+            else {
+                line = `[${m.role}]: ${(m.content || '').slice(0, COMPACT_MSG_CHARS)}`;
+            }
+            if (totalChars + line.length > COMPACT_TOTAL_CHARS)
+                break;
+            totalChars += line.length;
+            formatted.push(line);
+        }
+        const stopSpinner = startSpinner('compacting context');
+        let stopped = false;
+        try {
+            const res = await fetch(`${this.baseURL}/chat/completions`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${this.apiKey}` },
+                body: JSON.stringify({
+                    model: this.model,
+                    messages: [
+                        { role: 'system', content: COMPACTION_PROMPT },
+                        { role: 'user', content: formatted.join('\n\n') }
+                    ]
+                })
+            });
+            if (!res.ok)
+                throw new Error(`API ${res.status}: ${await res.text()}`);
+            const body = await res.json();
+            const summary = body.choices?.[0]?.message?.content;
+            if (!summary)
+                throw new Error('No summary returned');
+            const summaryMsg = {
+                role: 'user',
+                content: `[Conversation compacted — summary of ${middle.length} earlier messages]\n\n${summary}`
+            };
+            this.messages = [...head, summaryMsg, ...tail];
+            appendHistory(summaryMsg, this.cwd);
+            // Re-estimate context usage from the compacted messages
+            const compactedChars = this.messages.reduce((sum, m) => sum + (m.content?.length ?? 0), 0)
+                + this.systemPrompt.length;
+            this.contextTracker.estimateFromChars(compactedChars);
+            stopSpinner();
+            stopped = true;
+            process.stderr.write(`  ${C.yellow}Context compacted: ${middle.length} messages → summary${C.reset}\n`);
+        }
+        finally {
+            if (!stopped)
+                stopSpinner();
+        }
+    }
+    async chat(content) {
+        const userMessage = { role: 'user', content };
+        this.messages.push(userMessage);
+        appendHistory(userMessage, this.cwd);
+        // Cap in-memory messages to prevent unbounded growth
+        if (this.messages.length > MAX_MESSAGES) {
+            this.messages = this.messages.slice(-MAX_MESSAGES);
+        }
+        for (let i = 0; i < this.maxIterations; i++) {
+            const iterLabel = this.maxIterations > 1 ? ` [${i + 1}/${this.maxIterations}]` : '';
+            const stopSpinner = startSpinner(`thinking${iterLabel}`);
+            let msg;
+            try {
+                const res = await fetch(`${this.baseURL}/chat/completions`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${this.apiKey}` },
+                    body: JSON.stringify({
+                        model: this.model,
+                        messages: [{ role: 'system', content: this.systemPrompt }, ...this.messages],
+                        tools: Array.from(this.tools.values()).map(t => ({ type: t.type, function: t.function })),
+                        tool_choice: 'auto'
+                    })
+                });
+                if (!res.ok)
+                    throw new Error(`API ${res.status}: ${await res.text()}`);
+                const body = await res.json();
+                if (!body || typeof body !== 'object' || !Array.isArray(body.choices) || !body.choices[0]?.message) {
+                    throw new Error(`Unexpected API response shape: ${JSON.stringify(body).slice(0, 200)}`);
+                }
+                msg = body.choices[0].message;
+                if (!msg)
+                    throw new Error('No response from model');
+                if (body.usage)
+                    this.contextTracker.update(body.usage);
+            }
+            finally {
+                stopSpinner();
+            }
+            // Compact conversation if approaching context limit
+            if (!this.compactionInProgress && this.contextTracker.shouldCompact(COMPACT_THRESHOLD)) {
+                this.compactionInProgress = true;
+                try {
+                    await this.compactConversation();
+                }
+                catch (e) {
+                    process.stderr.write(`  ${C.dim}Compaction failed: ${e} — falling back to truncation${C.reset}\n`);
+                    // Fallback: simple truncation to prevent context overflow
+                    const keep = COMPACT_HEAD_KEEP + COMPACT_TAIL_KEEP;
+                    if (this.messages.length > keep) {
+                        const head = this.messages.slice(0, COMPACT_HEAD_KEEP);
+                        const tail = this.messages.slice(-COMPACT_TAIL_KEEP);
+                        const truncMsg = {
+                            role: 'user',
+                            content: `[Conversation truncated — ${this.messages.length - keep} older messages removed to stay within context limit]`
+                        };
+                        this.messages = [...head, truncMsg, ...tail];
+                    }
+                }
+                finally {
+                    this.compactionInProgress = false;
+                }
+            }
+            this.messages.push(msg);
+            if (!msg.tool_calls?.length) {
+                appendHistory({ role: 'assistant', content: msg.content || '' }, this.cwd);
+                return msg.content || '';
+            }
+            // Execute tool calls in parallel
+            const toolPromises = msg.tool_calls.map(async (call) => {
+                const tool = this.tools.get(call.function.name);
+                if (!tool) {
+                    return { call, content: `Error: unknown tool "${call.function.name}"` };
+                }
+                let args;
+                try {
+                    args = JSON.parse(call.function.arguments || '{}');
+                }
+                catch {
+                    return { call, content: 'Error: malformed tool arguments' };
+                }
+                // Permission check
+                if (this.confirmToolCall && !isReadOnlyToolCall(call.function.name, args)) {
+                    const decision = await this.confirmToolCall(call.function.name, args);
+                    if (decision === 'deny') {
+                        return { call, content: 'Tool call denied by user.' };
+                    }
+                }
+                const summary = args.command ?? args.action ?? JSON.stringify(args).slice(0, 80);
+                const stopToolSpinner = startSpinner(`[${call.function.name}] ${summary}`);
+                try {
+                    const rawResult = await tool.execute(args);
+                    const result = truncateToolResult(rawResult);
+                    stopToolSpinner();
+                    const isError = result.startsWith('Error:') || result.startsWith('EXIT ');
+                    const icon = isError ? `${C.red}✗` : `${C.green}✓`;
+                    const preview = result.slice(0, 150).split('\n')[0];
+                    process.stderr.write(`  ${icon} ${C.dim}[${call.function.name}]${C.reset} ${C.dim}${preview}${result.length > 150 ? '...' : ''}${C.reset}\n`);
+                    return { call, content: result };
+                }
+                catch (error) {
+                    stopToolSpinner();
+                    const errMsg = `Tool error: ${error}`;
+                    process.stderr.write(`  ${C.red}✗ [${call.function.name}] ${errMsg}${C.reset}\n`);
+                    return { call, content: errMsg };
+                }
+            });
+            const results = await Promise.all(toolPromises);
+            for (const { call, content } of results) {
+                this.messages.push({ role: 'tool', tool_call_id: call.id, content });
+            }
+        }
+        return MAX_ITERATIONS_REACHED;
+    }
+    async *chatStream(content) {
+        const userMessage = { role: 'user', content };
+        this.messages.push(userMessage);
+        appendHistory(userMessage, this.cwd);
+        if (this.messages.length > MAX_MESSAGES) {
+            this.messages = this.messages.slice(-MAX_MESSAGES);
+        }
+        for (let i = 0; i < this.maxIterations; i++) {
+            const iterLabel = this.maxIterations > 1 ? ` [${i + 1}/${this.maxIterations}]` : '';
+            yield { type: 'thinking', content: `thinking${iterLabel}` };
+            // Compact if needed
+            if (!this.compactionInProgress && this.contextTracker.shouldCompact(COMPACT_THRESHOLD)) {
+                this.compactionInProgress = true;
+                try {
+                    await this.compactConversation();
+                }
+                catch (e) {
+                    const keep = COMPACT_HEAD_KEEP + COMPACT_TAIL_KEEP;
+                    if (this.messages.length > keep) {
+                        const head = this.messages.slice(0, COMPACT_HEAD_KEEP);
+                        const tail = this.messages.slice(-COMPACT_TAIL_KEEP);
+                        const truncMsg = {
+                            role: 'user',
+                            content: `[Conversation truncated — ${this.messages.length - keep} older messages removed to stay within context limit]`
+                        };
+                        this.messages = [...head, truncMsg, ...tail];
+                    }
+                }
+                finally {
+                    this.compactionInProgress = false;
+                }
+            }
+            const res = await fetch(`${this.baseURL}/chat/completions`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${this.apiKey}` },
+                body: JSON.stringify({
+                    model: this.model,
+                    messages: [{ role: 'system', content: this.systemPrompt }, ...this.messages],
+                    tools: Array.from(this.tools.values()).map(t => ({ type: t.type, function: t.function })),
+                    tool_choice: 'auto',
+                    stream: true
+                })
+            });
+            if (!res.ok)
+                throw new Error(`API ${res.status}: ${await res.text()}`);
+            if (!res.body)
+                throw new Error('No response body for streaming');
+            // Parse SSE stream
+            let assistantContent = '';
+            const toolCalls = new Map();
+            let usage = null;
+            const reader = res.body.getReader();
+            const decoder = new TextDecoder();
+            let buffer = '';
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split('\n');
+                buffer = lines.pop() || '';
+                for (const line of lines) {
+                    if (!line.startsWith('data: '))
+                        continue;
+                    const data = line.slice(6).trim();
+                    if (data === '[DONE]')
+                        continue;
+                    let parsed;
+                    try {
+                        parsed = JSON.parse(data);
+                    }
+                    catch {
+                        continue;
+                    }
+                    const delta = parsed.choices?.[0]?.delta;
+                    if (!delta) {
+                        if (parsed.usage)
+                            usage = parsed.usage;
+                        continue;
+                    }
+                    // Text content
+                    if (delta.content) {
+                        assistantContent += delta.content;
+                        yield { type: 'text', content: delta.content };
+                    }
+                    // Tool calls (streamed incrementally)
+                    if (delta.tool_calls) {
+                        // Signal spinner on first tool_call delta so the user sees activity
+                        if (toolCalls.size === 0) {
+                            yield { type: 'thinking', content: 'running tools' };
+                        }
+                        for (const tc of delta.tool_calls) {
+                            const idx = tc.index ?? 0;
+                            if (!toolCalls.has(idx)) {
+                                toolCalls.set(idx, { id: tc.id || '', name: tc.function?.name || '', arguments: '' });
+                            }
+                            const entry = toolCalls.get(idx);
+                            if (tc.id)
+                                entry.id = tc.id;
+                            if (tc.function?.name)
+                                entry.name = tc.function.name;
+                            if (tc.function?.arguments)
+                                entry.arguments += tc.function.arguments;
+                        }
+                    }
+                }
+            }
+            if (usage)
+                this.contextTracker.update(usage);
+            // Build assistant message
+            const msg = { role: 'assistant', content: assistantContent || null };
+            if (toolCalls.size > 0) {
+                msg.tool_calls = Array.from(toolCalls.values()).map(tc => ({
+                    id: tc.id,
+                    type: 'function',
+                    function: { name: tc.name, arguments: tc.arguments }
+                }));
+            }
+            this.messages.push(msg);
+            if (!msg.tool_calls?.length) {
+                appendHistory({ role: 'assistant', content: assistantContent }, this.cwd);
+                yield { type: 'done', content: assistantContent };
+                return;
+            }
+            // Notify consumers that tools are about to run (shows spinner immediately)
+            for (const call of msg.tool_calls) {
+                const args = (() => { try {
+                    return JSON.parse(call.function.arguments || '{}');
+                }
+                catch {
+                    return {};
+                } })();
+                const summary = args.command ?? args.action ?? call.function.name;
+                yield { type: 'tool_start', toolName: call.function.name, toolCallId: call.id, content: summary };
+            }
+            // Execute tool calls in parallel
+            const execPromises = msg.tool_calls.map(async (call) => {
+                const tool = this.tools.get(call.function.name);
+                if (!tool)
+                    return { call, content: `Error: unknown tool "${call.function.name}"`, isError: true };
+                let args;
+                try {
+                    args = JSON.parse(call.function.arguments || '{}');
+                }
+                catch {
+                    return { call, content: 'Error: malformed tool arguments', isError: true };
+                }
+                // Permission check
+                if (this.confirmToolCall && !isReadOnlyToolCall(call.function.name, args)) {
+                    const decision = await this.confirmToolCall(call.function.name, args);
+                    if (decision === 'deny') {
+                        return { call, content: 'Tool call denied by user.', isError: true };
+                    }
+                }
+                try {
+                    const rawResult = await tool.execute(args);
+                    const result = truncateToolResult(rawResult);
+                    const isError = result.startsWith('Error:') || result.startsWith('EXIT ');
+                    return { call, content: result, isError };
+                }
+                catch (error) {
+                    return { call, content: `Tool error: ${error}`, isError: true };
+                }
+            });
+            const execResults = await Promise.all(execPromises);
+            for (const r of execResults) {
+                this.messages.push({ role: 'tool', tool_call_id: r.call.id, content: r.content });
+                yield { type: 'tool_end', toolName: r.call.function.name, toolCallId: r.call.id, content: r.content, success: !r.isError };
+            }
+        }
+        yield { type: 'max_iterations' };
+    }
+    // ── Public API ─────────────────────────────────────────────────────────────
+    getTools() {
+        return Array.from(this.tools.values()).map(t => ({ name: t.function.name, description: t.function.description }));
+    }
+    getModel() { return this.model; }
+    getBaseURL() { return this.baseURL; }
+    setModel(model) { this.model = model; this.contextTracker = new ContextTracker(model); }
+    setConfirmToolCall(cb) { this.confirmToolCall = cb; }
+    async compactNow() { await this.compactConversation(); }
+    async fetchModels(query) {
+        const res = await fetch(`${this.baseURL}/models`, {
+            headers: { 'Authorization': `Bearer ${this.apiKey}` }
+        });
+        if (!res.ok)
+            throw new Error(`Failed to fetch models: ${res.status}`);
+        const data = await res.json();
+        let models = data.data || [];
+        if (query) {
+            const q = query.toLowerCase();
+            models = models.filter(m => m.id.toLowerCase().includes(q) || m.name.toLowerCase().includes(q));
+        }
+        return models;
+    }
+    getSkills() { return this.allSkills; }
+    getActiveSkillNames() {
+        const names = [];
+        for (const c of this.activeSkillContent) {
+            const match = c.match(/name="([^"]+)"/);
+            if (match)
+                names.push(match[1]);
+        }
+        return names;
+    }
+    refreshSkills() { this.allSkills = discoverSkills(this.cwd); this.refreshCache(); }
+    getStats() { return getStats(this.cwd); }
+    getPaths() { return paths(this.cwd); }
+    getGlobalMemory() { return loadGlobalMemory(this.cwd); }
+    getProjectMemory() { return loadProjectMemory(this.cwd); }
+    getPlan() { return loadPlan(this.cwd); }
+    getPlanByName(name) { return loadPlanByName(name, this.cwd); }
+    getPlans() { return listPlans(this.cwd); }
+    setGlobalMemory(content) { saveGlobalMemory(content, this.cwd); }
+    setProjectMemory(content) { saveProjectMemory(content, this.cwd); }
+    setPlan(content, name) { savePlan(content, name, this.cwd); }
+    appendToPlan(content) { appendPlan(content, this.cwd); }
+    activatePlan(name) { setActivePlan(name, this.cwd); }
+    getActivePlanName() { return getActivePlanName(this.cwd); }
+    clearProject() { this.messages = []; this.contextTracker.reset(); clearProject(this.cwd); }
+    clearAll() { this.messages = []; this.contextTracker.reset(); clearAll(this.cwd); }
+    // ── Context tracking ───────────────────────────────────────────────────
+    getContextUsage() { return this.contextTracker.format(); }
+    getContextDetails() { return this.contextTracker.formatDetailed(); }
+    getContextTracker() { return this.contextTracker; }
+    getSystemPromptSize() { return this.systemPrompt.length; }
+}
+//# sourceMappingURL=agent.js.map