@element47/ag 4.4.5 → 4.5.2

package/dist/core/agent.js

@@ -118,6 +118,16 @@ export function truncateToolResult(result) {
     const omitted = lines.length - TRUNCATION_HEAD_LINES - TRUNCATION_TAIL_LINES;
     return [...head, `\n... [${omitted} lines truncated] ...\n`, ...tail].join('\n');
 }
+/** Yield promise results as they resolve (like Promise.all but streaming) */
+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) {
+        const result = await Promise.race(wrapped.filter((_, idx) => !settled.has(idx)));
+        settled.add(result.i);
+        yield result.v;
+    }
+}
 export class Agent {
     apiKey;
     model;
@@ -133,6 +143,7 @@ export class Agent {
     cachedCatalog = '';
     cachedAlwaysOn = '';
     builtinToolNames = new Set();
+    toolFailures;
     contextTracker;
     compactionInProgress = false;
     confirmToolCall;
@@ -178,6 +189,7 @@ export class Agent {
 - 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.
+- Always follow instructions in <global-memory> — these are persistent user preferences that override defaults.
 
 # Verification
 - After making changes, verify they work: run tests, check for syntax errors, or start the dev server as appropriate.
@@ -211,6 +223,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)
@@ -282,6 +295,24 @@ export class Agent {
         }
         return parts.join('\n\n');
     }
+    /** Build the JSON request body for chat completions, with prompt caching for supported models */
+    buildRequestBody(stream) {
+        const body = {
+            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 (stream) {
+            body.stream = true;
+            body.stream_options = { include_usage: true };
+        }
+        // Enable prompt caching for Anthropic models (top-level cache_control)
+        if (this.model.startsWith('anthropic/') || this.model.includes('claude')) {
+            body.cache_control = { type: 'ephemeral' };
+        }
+        return body;
+    }
     async activateSkill(name) {
         const skill = this.allSkills.find(s => s.name === name);
         if (!skill)
@@ -368,7 +399,7 @@ export class Agent {
                 stopSpinner();
         }
     }
-    async chat(content) {
+    async chat(content, signal) {
         const userMessage = { role: 'user', content };
         this.messages.push(userMessage);
         appendHistory(userMessage, this.cwd);
@@ -377,6 +408,10 @@ export class Agent {
             this.messages = this.messages.slice(-MAX_MESSAGES);
         }
         for (let i = 0; i < this.maxIterations; i++) {
+            if (signal?.aborted) {
+                this.messages.push({ role: 'assistant', content: '[interrupted by user]' });
+                return '[interrupted by user]';
+            }
             const iterLabel = this.maxIterations > 1 ? ` [${i + 1}/${this.maxIterations}]` : '';
             const stopSpinner = startSpinner(`thinking${iterLabel}`);
             let msg;
@@ -384,12 +419,8 @@ export class Agent {
                 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'
-                    })
+                    body: JSON.stringify(this.buildRequestBody(false)),
+                    signal
                 });
                 if (!res.ok)
                     throw new Error(`API ${res.status}: ${await res.text()}`);
@@ -431,11 +462,28 @@ export class Agent {
                 }
             }
             this.messages.push(msg);
+            appendHistory(msg, this.cwd);
             if (!msg.tool_calls?.length) {
-                appendHistory({ role: 'assistant', content: msg.content || '' }, this.cwd);
                 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) {
@@ -448,12 +496,8 @@ 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.' };
                 }
                 const summary = args.command ?? args.action ?? JSON.stringify(args).slice(0, 80);
                 const stopToolSpinner = startSpinner(`[${call.function.name}] ${summary}`);
@@ -477,11 +521,12 @@ export class Agent {
             const results = await Promise.all(toolPromises);
             for (const { call, content } of results) {
                 this.messages.push({ role: 'tool', tool_call_id: call.id, content });
+                appendHistory({ role: 'tool', tool_call_id: call.id, content }, this.cwd);
             }
         }
         return MAX_ITERATIONS_REACHED;
     }
-    async *chatStream(content) {
+    async *chatStream(content, signal) {
         const userMessage = { role: 'user', content };
         this.messages.push(userMessage);
         appendHistory(userMessage, this.cwd);
@@ -489,6 +534,12 @@ export class Agent {
             this.messages = this.messages.slice(-MAX_MESSAGES);
         }
         for (let i = 0; i < this.maxIterations; i++) {
+            // ── Abort check: top of iteration ──
+            if (signal?.aborted) {
+                this.messages.push({ role: 'assistant', content: '[interrupted by user]' });
+                yield { type: 'interrupted' };
+                return;
+            }
             const iterLabel = this.maxIterations > 1 ? ` [${i + 1}/${this.maxIterations}]` : '';
             yield { type: 'thinking', content: `thinking${iterLabel}` };
             // Compact if needed
@@ -513,17 +564,24 @@ export class Agent {
                     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
-                })
-            });
+            // ── 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)),
+                    signal
+                });
+            }
+            catch (e) {
+                if (e instanceof DOMException && e.name === 'AbortError') {
+                    this.messages.push({ role: 'assistant', content: '[interrupted by user]' });
+                    yield { type: 'interrupted' };
+                    return;
+                }
+                throw e;
+            }
             if (!res.ok)
                 throw new Error(`API ${res.status}: ${await res.text()}`);
             if (!res.body)
@@ -532,62 +590,89 @@ export class Agent {
             let assistantContent = '';
             const toolCalls = new Map();
             let usage = null;
+            let streamAborted = false;
             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;
+            try {
+                while (true) {
+                    if (signal?.aborted) {
+                        streamAborted = true;
+                        break;
                     }
-                    const delta = parsed.choices?.[0]?.delta;
-                    if (!delta) {
+                    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;
+                        }
+                        // Capture usage from any chunk that has it (may coexist with 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' };
+                        const delta = parsed.choices?.[0]?.delta;
+                        if (!delta)
+                            continue;
+                        // Text content
+                        if (delta.content) {
+                            assistantContent += delta.content;
+                            yield { type: 'text', content: delta.content };
                         }
-                        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: '' });
+                        // Tool calls (streamed incrementally)
+                        if (delta.tool_calls) {
+                            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;
+                                    // Show tool names as they arrive (replaces spinner in real-time)
+                                    const names = [...toolCalls.values()].map(t => t.name).filter(Boolean);
+                                    yield { type: 'thinking', content: `preparing ${names.join(', ')}` };
+                                }
+                                if (tc.function?.arguments)
+                                    entry.arguments += tc.function.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;
                         }
                     }
                 }
             }
+            catch (e) {
+                if (e instanceof DOMException && e.name === 'AbortError') {
+                    streamAborted = true;
+                }
+                else {
+                    throw e;
+                }
+            }
+            finally {
+                try {
+                    reader.cancel();
+                }
+                catch { /* already closed */ }
+            }
+            // If aborted during streaming, discard partial message
+            if (streamAborted) {
+                this.messages.push({ role: 'assistant', content: '[interrupted by user]' });
+                yield { type: 'interrupted' };
+                return;
+            }
             if (usage)
                 this.contextTracker.update(usage);
             // Build assistant message
@@ -600,8 +685,8 @@ export class Agent {
                 }));
             }
             this.messages.push(msg);
+            appendHistory(msg, this.cwd);
             if (!msg.tool_calls?.length) {
-                appendHistory({ role: 'assistant', content: assistantContent }, this.cwd);
                 yield { type: 'done', content: assistantContent };
                 return;
             }
@@ -616,8 +701,29 @@ 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 };
             }
-            // 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) {
+                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)
+                    return { call, content: '[cancelled by user]', isError: true };
                 const tool = this.tools.get(call.function.name);
                 if (!tool)
                     return { call, content: `Error: unknown tool "${call.function.name}"`, isError: true };
@@ -628,12 +734,8 @@ 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 };
                 }
                 try {
                     const rawResult = await tool.execute(args);
@@ -645,18 +747,89 @@ export class Agent {
                     return { call, content: `Tool error: ${error}`, isError: true };
                 }
             });
-            const execResults = await Promise.all(execPromises);
-            for (const r of execResults) {
+            // Yield results as they resolve (not waiting for all)
+            const completedCallIds = new Set();
+            for await (const r of raceAll(execPromises)) {
+                completedCallIds.add(r.call.id);
                 this.messages.push({ role: 'tool', tool_call_id: r.call.id, content: r.content });
+                appendHistory({ role: 'tool', tool_call_id: r.call.id, content: r.content }, this.cwd);
                 yield { type: 'tool_end', toolName: r.call.function.name, toolCallId: r.call.id, content: r.content, success: !r.isError };
+                // Check abort after each tool completes
+                if (signal?.aborted)
+                    break;
+            }
+            // Fill placeholders for any tool calls that didn't complete (API requires all tool_call_ids)
+            if (signal?.aborted && msg.tool_calls) {
+                for (const call of msg.tool_calls) {
+                    if (!completedCallIds.has(call.id)) {
+                        const placeholder = { role: 'tool', tool_call_id: call.id, content: '[cancelled by user]' };
+                        this.messages.push(placeholder);
+                        appendHistory(placeholder, this.cwd);
+                    }
+                }
+                this.messages.push({ role: 'assistant', content: '[interrupted by user]' });
+                yield { type: 'interrupted', content: `${completedCallIds.size} completed, ${msg.tool_calls.length - completedCallIds.size} cancelled` };
+                return;
             }
         }
         yield { type: 'max_iterations' };
     }
     // ── Public API ─────────────────────────────────────────────────────────────
+    /** Return the char-size breakdown of every context component */
+    getContextBreakdown() {
+        const parts = [];
+        parts.push({ label: 'System prompt', chars: this.baseSystemPrompt.length });
+        parts.push({ label: 'Environment', chars: getEnvironmentContext(this.cwd).length });
+        const listing = this.getProjectListing();
+        if (listing)
+            parts.push({ label: 'Project files', chars: listing.length });
+        // cachedContext contains global memory + project memory + plan, but we want them separate
+        const globalMem = loadGlobalMemory(this.cwd);
+        const projectMem = loadProjectMemory(this.cwd);
+        const plan = loadPlan(this.cwd);
+        if (globalMem)
+            parts.push({ label: 'Global memory', chars: globalMem.length + '<global-memory>\n\n</global-memory>'.length });
+        if (projectMem)
+            parts.push({ label: 'Project memory', chars: projectMem.length + '<project-memory>\n\n</project-memory>'.length });
+        if (plan)
+            parts.push({ label: 'Plan', chars: plan.length + 50 /* tags + header */ });
+        if (this.cachedCatalog)
+            parts.push({ label: 'Skill catalog', chars: this.cachedCatalog.length });
+        if (this.cachedAlwaysOn)
+            parts.push({ label: 'Always-on skills', chars: this.cachedAlwaysOn.length });
+        if (this.activeSkillContent.length > 0) {
+            parts.push({ label: 'Active skills', chars: this.activeSkillContent.join('\n\n').length });
+        }
+        // Tool definitions (sent in every API call as the tools array)
+        const builtinChars = Array.from(this.tools.values())
+            .filter(t => this.builtinToolNames.has(t.function.name))
+            .reduce((sum, t) => sum + JSON.stringify({ type: t.type, function: t.function }).length, 0);
+        const customChars = Array.from(this.tools.values())
+            .filter(t => !this.builtinToolNames.has(t.function.name))
+            .reduce((sum, t) => sum + JSON.stringify({ type: t.type, function: t.function }).length, 0);
+        if (builtinChars > 0)
+            parts.push({ label: 'Tool definitions', chars: builtinChars });
+        if (customChars > 0)
+            parts.push({ label: 'Custom tools', chars: customChars });
+        // Messages (conversation history)
+        const msgChars = this.messages.reduce((sum, m) => {
+            let size = (m.content || '').length;
+            if (m.tool_calls)
+                size += JSON.stringify(m.tool_calls).length;
+            return sum + size;
+        }, 0);
+        if (msgChars > 0)
+            parts.push({ label: 'Messages', chars: msgChars });
+        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); }
@@ -708,5 +881,9 @@ export class Agent {
     getContextDetails() { return this.contextTracker.formatDetailed(); }
     getContextTracker() { return this.contextTracker; }
     getSystemPromptSize() { return this.systemPrompt.length; }
+    /** Total estimated chars across all context components (system prompt + tools + messages) */
+    getTotalContextChars() {
+        return this.getContextBreakdown().reduce((sum, p) => sum + p.chars, 0);
+    }
 }
 //# sourceMappingURL=agent.js.map