@element47/ag 4.5.1 → 4.5.3

package/dist/core/agent.js

@@ -1,6 +1,8 @@
 import { readdirSync, statSync, existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { execFileSync } from 'node:child_process';
+import { AgentEventEmitter } from './events.js';
+import { discoverExtensions, loadExtensions } from './extensions.js';
 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';
@@ -119,7 +121,7 @@ export function truncateToolResult(result) {
     return [...head, `\n... [${omitted} lines truncated] ...\n`, ...tail].join('\n');
 }
 /** Yield promise results as they resolve (like Promise.all but streaming) */
-async function* raceAll(promises) {
+export async function* raceAll(promises) {
     const wrapped = promises.map((p, i) => p.then(v => ({ i, v })));
     const settled = new Set();
     while (settled.size < promises.length) {
@@ -143,9 +145,13 @@ export class Agent {
     cachedCatalog = '';
     cachedAlwaysOn = '';
     builtinToolNames = new Set();
+    toolFailures;
     contextTracker;
     compactionInProgress = false;
     confirmToolCall;
+    events = new AgentEventEmitter();
+    loadedExtensions = [];
+    spinnerControl = null;
     constructor(config = {}) {
         this.apiKey = config.apiKey || process.env.OPENROUTER_API_KEY || '';
         if (!this.apiKey)
@@ -222,6 +228,7 @@ export class Agent {
         this.builtinToolNames = new Set(this.tools.keys());
         for (const t of config.extraTools ?? [])
             this.addTool(t);
+        this.toolFailures = config.toolFailures ?? [];
         // Context window tracking
         this.contextTracker = new ContextTracker(this.model);
         // Cache context and skill catalog (invalidated on skill activation/refresh)
@@ -236,6 +243,34 @@ export class Agent {
         }
         this.tools.set(name, tool);
     }
+    /** Subscribe to an agent lifecycle event. Returns an unsubscribe function. */
+    on(event, handler) {
+        return this.events.on(event, handler);
+    }
+    /** Discover and load extensions from .ag/extensions/ and ~/.ag/extensions/ */
+    async initExtensions(extraPaths) {
+        const discovered = discoverExtensions(this.cwd);
+        const all = [...discovered, ...(extraPaths ?? [])];
+        if (all.length > 0) {
+            this.loadedExtensions = await loadExtensions(this, all);
+        }
+    }
+    /** Metadata for successfully loaded extensions */
+    getLoadedExtensions() {
+        return this.loadedExtensions;
+    }
+    /** Spinner-safe log for extensions. Pauses spinner, writes, resumes. */
+    log(message) {
+        if (this.spinnerControl)
+            this.spinnerControl.pause();
+        process.stderr.write(message + '\n');
+        if (this.spinnerControl)
+            this.spinnerControl.resume();
+    }
+    /** Called by the REPL to register spinner pause/resume for safe output */
+    setSpinnerControl(control) {
+        this.spinnerControl = control;
+    }
     refreshCache() {
         this.cachedContext = loadContext(this.cwd);
         this.cachedCatalog = buildSkillCatalog(this.allSkills);
@@ -294,10 +329,12 @@ export class Agent {
         return parts.join('\n\n');
     }
     /** Build the JSON request body for chat completions, with prompt caching for supported models */
-    buildRequestBody(stream) {
+    buildRequestBody(stream, overrides) {
+        const sysPrompt = overrides?.systemPrompt ?? this.systemPrompt;
+        const msgs = overrides?.messages ?? this.messages;
         const body = {
             model: this.model,
-            messages: [{ role: 'system', content: this.systemPrompt }, ...this.messages],
+            messages: [{ role: 'system', content: sysPrompt }, ...msgs],
             tools: Array.from(this.tools.values()).map(t => ({ type: t.type, function: t.function })),
             tool_choice: 'auto',
         };
@@ -331,73 +368,86 @@ export class Agent {
         }
         return `Skill "${name}" activated. Instructions loaded.`;
     }
-    async compactConversation() {
+    async compactConversation(customSummary) {
         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})`;
+        let summary;
+        if (customSummary) {
+            // Use extension-provided summary instead of LLM call
+            summary = customSummary;
+        }
+        else {
+            // 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);
             }
-            else if (m.role === 'tool') {
-                line = `[tool result]: ${(m.content || '').slice(0, COMPACT_MSG_CHARS)}`;
+            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();
+                summary = body.choices?.[0]?.message?.content;
+                if (!summary)
+                    throw new Error('No summary returned');
+                stopSpinner();
+                stopped = true;
             }
-            else {
-                line = `[${m.role}]: ${(m.content || '').slice(0, COMPACT_MSG_CHARS)}`;
+            finally {
+                if (!stopped)
+                    stopSpinner();
             }
-            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();
         }
+        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);
+        process.stderr.write(`  ${C.yellow}Context compacted: ${middle.length} messages → summary${C.reset}\n`);
     }
     async chat(content, signal) {
+        // ── input event ──
+        const inputEvent = { content, skip: false };
+        await this.events.emit('input', inputEvent);
+        if (inputEvent.skip)
+            return '';
+        content = inputEvent.content;
         const userMessage = { role: 'user', content };
         this.messages.push(userMessage);
         appendHistory(userMessage, this.cwd);
@@ -410,14 +460,46 @@ export class Agent {
                 this.messages.push({ role: 'assistant', content: '[interrupted by user]' });
                 return '[interrupted by user]';
             }
+            // ── turn_start event ──
+            await this.events.emit('turn_start', { iteration: i, maxIterations: this.maxIterations, messageCount: this.messages.length });
             const iterLabel = this.maxIterations > 1 ? ` [${i + 1}/${this.maxIterations}]` : '';
             const stopSpinner = startSpinner(`thinking${iterLabel}`);
+            // ── before_compact event ──
+            if (!this.compactionInProgress && this.contextTracker.shouldCompact(COMPACT_THRESHOLD)) {
+                const compactEvent = { messageCount: this.messages.length, cancel: false, customSummary: undefined };
+                await this.events.emit('before_compact', compactEvent);
+                if (!compactEvent.cancel) {
+                    this.compactionInProgress = true;
+                    try {
+                        await this.compactConversation(compactEvent.customSummary);
+                    }
+                    catch (e) {
+                        process.stderr.write(`  ${C.dim}Compaction failed: ${e} — falling back to truncation${C.reset}\n`);
+                        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;
+                    }
+                }
+            }
+            // ── before_request event ──
+            const reqEvent = { messages: this.messages, systemPrompt: this.systemPrompt, model: this.model, stream: false };
+            await this.events.emit('before_request', reqEvent);
             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(this.buildRequestBody(false)),
+                    body: JSON.stringify(this.buildRequestBody(false, { messages: reqEvent.messages, systemPrompt: reqEvent.systemPrompt })),
                     signal
                 });
                 if (!res.ok)
@@ -435,36 +517,33 @@ export class Agent {
             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;
-                }
-            }
+            // ── after_response event ──
+            await this.events.emit('after_response', { message: msg, usage: undefined });
             this.messages.push(msg);
             appendHistory(msg, this.cwd);
             if (!msg.tool_calls?.length) {
+                // ── turn_end event (no tools) ──
+                await this.events.emit('turn_end', { iteration: i, hadToolCalls: false, toolCallCount: 0 });
                 return msg.content || '';
             }
-            // Execute tool calls in parallel
+            // Permission checks — run sequentially so prompts don't overlap
+            const permissionDecisions = new Map();
+            for (const call of msg.tool_calls) {
+                const tool = this.tools.get(call.function.name);
+                if (!tool)
+                    continue;
+                let args;
+                try {
+                    args = JSON.parse(call.function.arguments || '{}');
+                }
+                catch {
+                    continue;
+                }
+                if (this.confirmToolCall && !isReadOnlyToolCall(call.function.name, args)) {
+                    permissionDecisions.set(call.id, await this.confirmToolCall(call.function.name, args, tool.permissionKey));
+                }
+            }
+            // Execute tool calls in parallel (permissions already resolved)
             const toolPromises = msg.tool_calls.map(async (call) => {
                 const tool = this.tools.get(call.function.name);
                 if (!tool) {
@@ -477,20 +556,28 @@ export class Agent {
                 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.' };
-                    }
+                if (permissionDecisions.get(call.id) === 'deny') {
+                    return { call, content: 'Tool call denied by user.' };
+                }
+                // ── tool_call event ──
+                const tcEvent = { toolName: call.function.name, toolCallId: call.id, args, block: false, blockReason: undefined };
+                await this.events.emit('tool_call', tcEvent);
+                if (tcEvent.block) {
+                    return { call, content: tcEvent.blockReason || 'Blocked by extension' };
                 }
+                args = tcEvent.args;
                 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);
+                    let result = truncateToolResult(rawResult);
+                    let isError = result.startsWith('Error:') || result.startsWith('EXIT ');
+                    // ── tool_result event ──
+                    const trEvent = { toolName: call.function.name, toolCallId: call.id, args, content: result, isError };
+                    await this.events.emit('tool_result', trEvent);
+                    result = trEvent.content;
+                    isError = trEvent.isError;
                     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`);
@@ -508,10 +595,18 @@ export class Agent {
                 this.messages.push({ role: 'tool', tool_call_id: call.id, content });
                 appendHistory({ role: 'tool', tool_call_id: call.id, content }, this.cwd);
             }
+            // ── turn_end event ──
+            await this.events.emit('turn_end', { iteration: i, hadToolCalls: true, toolCallCount: msg.tool_calls.length });
         }
         return MAX_ITERATIONS_REACHED;
     }
     async *chatStream(content, signal) {
+        // ── input event ──
+        const inputEvent = { content, skip: false };
+        await this.events.emit('input', inputEvent);
+        if (inputEvent.skip)
+            return;
+        content = inputEvent.content;
         const userMessage = { role: 'user', content };
         this.messages.push(userMessage);
         appendHistory(userMessage, this.cwd);
@@ -525,37 +620,46 @@ export class Agent {
                 yield { type: 'interrupted' };
                 return;
             }
+            // ── turn_start event ──
+            await this.events.emit('turn_start', { iteration: i, maxIterations: this.maxIterations, messageCount: this.messages.length });
             const iterLabel = this.maxIterations > 1 ? ` [${i + 1}/${this.maxIterations}]` : '';
             yield { type: 'thinking', content: `thinking${iterLabel}` };
-            // Compact if needed
+            // ── before_compact event ──
             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];
+                const compactEvent = { messageCount: this.messages.length, cancel: false, customSummary: undefined };
+                await this.events.emit('before_compact', compactEvent);
+                if (!compactEvent.cancel) {
+                    this.compactionInProgress = true;
+                    try {
+                        await this.compactConversation(compactEvent.customSummary);
+                    }
+                    catch {
+                        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;
                     }
-                }
-                finally {
-                    this.compactionInProgress = false;
                 }
             }
+            // ── before_request event ──
+            const reqEvent = { messages: this.messages, systemPrompt: this.systemPrompt, model: this.model, stream: true };
+            await this.events.emit('before_request', reqEvent);
             // ── API call with abort signal ──
             let res;
             try {
                 res = await fetch(`${this.baseURL}/chat/completions`, {
                     method: 'POST',
                     headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${this.apiKey}` },
-                    body: JSON.stringify(this.buildRequestBody(true)),
+                    body: JSON.stringify(this.buildRequestBody(true, { messages: reqEvent.messages, systemPrompt: reqEvent.systemPrompt })),
                     signal
                 });
             }
@@ -669,10 +773,14 @@ export class Agent {
                     function: { name: tc.name, arguments: tc.arguments }
                 }));
             }
+            // ── after_response event ──
+            await this.events.emit('after_response', { message: msg, usage: usage ?? undefined });
             this.messages.push(msg);
             appendHistory(msg, this.cwd);
             if (!msg.tool_calls?.length) {
-                yield { type: 'done', content: assistantContent };
+                // ── turn_end event (no tools) ──
+                await this.events.emit('turn_end', { iteration: i, hadToolCalls: false, toolCallCount: 0 });
+                yield { type: 'done', content: msg.content || '' };
                 return;
             }
             // Notify consumers that tools are about to run (shows spinner immediately)
@@ -686,6 +794,25 @@ export class Agent {
                 const summary = args.command ?? args.action ?? call.function.name;
                 yield { type: 'tool_start', toolName: call.function.name, toolCallId: call.id, content: summary };
             }
+            // Permission checks — run sequentially so prompts don't overlap
+            const permissionDecisions = new Map();
+            for (const call of msg.tool_calls) {
+                if (signal?.aborted)
+                    break;
+                const tool = this.tools.get(call.function.name);
+                if (!tool)
+                    continue;
+                let args;
+                try {
+                    args = JSON.parse(call.function.arguments || '{}');
+                }
+                catch {
+                    continue;
+                }
+                if (this.confirmToolCall && !isReadOnlyToolCall(call.function.name, args)) {
+                    permissionDecisions.set(call.id, await this.confirmToolCall(call.function.name, args, tool.permissionKey));
+                }
+            }
             // Execute tool calls — yield results as they complete (not Promise.all)
             const execPromises = msg.tool_calls.map(async (call) => {
                 if (signal?.aborted)
@@ -700,17 +827,25 @@ export class Agent {
                 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 };
-                    }
+                if (permissionDecisions.get(call.id) === 'deny') {
+                    return { call, content: 'Tool call denied by user.', isError: true };
+                }
+                // ── tool_call event ──
+                const tcEvent = { toolName: call.function.name, toolCallId: call.id, args, block: false, blockReason: undefined };
+                await this.events.emit('tool_call', tcEvent);
+                if (tcEvent.block) {
+                    return { call, content: tcEvent.blockReason || 'Blocked by extension', isError: true };
                 }
+                args = tcEvent.args;
                 try {
                     const rawResult = await tool.execute(args);
-                    const result = truncateToolResult(rawResult);
-                    const isError = result.startsWith('Error:') || result.startsWith('EXIT ');
+                    let result = truncateToolResult(rawResult);
+                    let isError = result.startsWith('Error:') || result.startsWith('EXIT ');
+                    // ── tool_result event ──
+                    const trEvent = { toolName: call.function.name, toolCallId: call.id, args, content: result, isError };
+                    await this.events.emit('tool_result', trEvent);
+                    result = trEvent.content;
+                    isError = trEvent.isError;
                     return { call, content: result, isError };
                 }
                 catch (error) {
@@ -741,6 +876,8 @@ export class Agent {
                 yield { type: 'interrupted', content: `${completedCallIds.size} completed, ${msg.tool_calls.length - completedCallIds.size} cancelled` };
                 return;
             }
+            // ── turn_end event ──
+            await this.events.emit('turn_end', { iteration: i, hadToolCalls: true, toolCallCount: msg.tool_calls.length });
         }
         yield { type: 'max_iterations' };
     }
@@ -793,8 +930,13 @@ export class Agent {
         return parts;
     }
     getTools() {
-        return Array.from(this.tools.values()).map(t => ({ name: t.function.name, description: t.function.description }));
+        return Array.from(this.tools.values()).map(t => ({
+            name: t.function.name,
+            description: t.function.description,
+            isBuiltin: this.builtinToolNames.has(t.function.name),
+        }));
     }
+    getToolFailures() { return this.toolFailures; }
     getModel() { return this.model; }
     getBaseURL() { return this.baseURL; }
     setModel(model) { this.model = model; this.contextTracker = new ContextTracker(model); }