lonny-agent 0.2.3 → 0.2.6

package/dist/agent/session.js

@@ -4,6 +4,7 @@ import * as os from 'node:os';
 import * as path from 'node:path';
 import { saveTokenUsage } from '../config/tokens.js';
 import { FileReadTracker } from '../diff/apply.js';
+import { fmtErr } from '../tools/errors.js';
 import { ToolRegistry } from '../tools/registry.js';
 import { compact, shouldCompact } from './compaction.js';
 import { EventChannels, getGlobalEventBus } from './event-bus.js';
@@ -179,14 +180,33 @@ export function formatToolInput(tc) {
     }
     return parts.join(' \u2502 ');
 }
-function printTokenStats(turnIn, turnOut, totalIn, totalOut, turnApi, totalApi, output) {
+function printTokenStats(turnIn, turnOut, totalIn, totalOut, turnApi, totalApi, output, turnCacheHit, turnCacheMiss, totalCacheHit, totalCacheMiss) {
     const bus = getGlobalEventBus();
-    bus.emit(EventChannels.TOKEN_STATS, { turnIn, turnOut, totalIn, totalOut, turnApi, totalApi });
+    bus.emit(EventChannels.TOKEN_STATS, {
+        turnIn,
+        turnOut,
+        totalIn,
+        totalOut,
+        turnApi,
+        totalApi,
+        turnCacheHit,
+        turnCacheMiss,
+        totalCacheHit,
+        totalCacheMiss,
+    });
     // Skip terminal output in Web UI mode
     if (output?.suppressToolOutput)
         return;
     const total = totalIn + totalOut;
-    const msg = `  ${GY}┃${RS} ${GY}${BLD}▴${RS}${GY}${turnIn}${RS} ${GY}${BLD}▾${RS}${GY}${turnOut}${RS}  ${GY}total${RS} ${total}  ${GY}calls${RS} ${turnApi}(${totalApi})`;
+    let msg = `  ${GY}┃${RS} ${GY}${BLD}▴${RS}${GY}${turnIn}${RS} ${GY}${BLD}▾${RS}${GY}${turnOut}${RS}  ${GY}total${RS} ${total}  ${GY}calls${RS} ${turnApi}(${totalApi})`;
+    // Show cache hit rate if available
+    const cacheHit = totalCacheHit ?? 0;
+    const cacheMiss = totalCacheMiss ?? 0;
+    const cacheTotal = cacheHit + cacheMiss;
+    if (cacheTotal > 0) {
+        const pct = Math.round((cacheHit / cacheTotal) * 100);
+        msg += `  ${GY}cached${RS} ${pct}%`;
+    }
     writeOut(`\n${msg}\n`, output);
 }
 export class Session {
@@ -216,6 +236,10 @@ export class Session {
     turnOutputTokens = 0;
     turnApiCalls = 0;
     totalApiCalls = 0;
+    turnCacheHitTokens = 0;
+    turnCacheMissTokens = 0;
+    totalCacheHitTokens = 0;
+    totalCacheMissTokens = 0;
     stopped = false;
     abortController = null;
     constructor(config, output) {
@@ -241,7 +265,16 @@ export class Session {
         else {
             this.provider = new AnthropicProvider(config.apiKey, config.baseUrl, config.model);
         }
-        this.messages = [{ role: 'system', content: buildSystemPrompt(config) }];
+        // Placeholder until initSystemPrompt() is called
+        this.messages = [{ role: 'system', content: '' }];
+        // Initialize system prompt asynchronously
+        this.initSystemPrompt(config);
+    }
+    /** Initialize the system prompt asynchronously */
+    initSystemPrompt(config) {
+        buildSystemPrompt(config).then(prompt => {
+            this.messages = [{ role: 'system', content: prompt }];
+        });
     }
     /** Persist the current session to ~/.lonny/sessions/ */
     save() {
@@ -254,6 +287,8 @@ export class Session {
             totalInputTokens: this.totalInputTokens,
             totalOutputTokens: this.totalOutputTokens,
             totalApiCalls: this.totalApiCalls,
+            totalCacheHitTokens: this.totalCacheHitTokens || undefined,
+            totalCacheMissTokens: this.totalCacheMissTokens || undefined,
             mode: this.config.mode,
             model: this.config.model,
             provider: this.config.provider,
@@ -262,7 +297,7 @@ export class Session {
         fs.writeFileSync(filePath, JSON.stringify(data, null, 2), 'utf-8');
     }
     /** Try to load a saved session for the given cwd. Returns null if none exists. */
-    static load(config, output) {
+    static async load(config, output) {
         const filePath = getSessionFilePath(config.cwd);
         let data;
         try {
@@ -285,12 +320,15 @@ export class Session {
         if (data.model !== config.model ||
             data.provider !== config.provider ||
             data.mode !== config.mode) {
-            session.messages[0] = { role: 'system', content: buildSystemPrompt(config) };
+            const prompt = await buildSystemPrompt(config);
+            session.messages[0] = { role: 'system', content: prompt };
         }
         // Restore token stats
         session.totalInputTokens = data.totalInputTokens;
         session.totalOutputTokens = data.totalOutputTokens;
         session.totalApiCalls = data.totalApiCalls;
+        session.totalCacheHitTokens = data.totalCacheHitTokens ?? 0;
+        session.totalCacheMissTokens = data.totalCacheMissTokens ?? 0;
         return session;
     }
     /** Remove the saved session file for the given cwd. */
@@ -303,9 +341,10 @@ export class Session {
             // Ignore if file doesn't exist
         }
     }
-    setMode(mode) {
+    async setMode(mode) {
         this.config.mode = mode;
-        this.messages[0] = { role: 'system', content: buildSystemPrompt(this.config) };
+        const prompt = await buildSystemPrompt(this.config);
+        this.messages[0] = { role: 'system', content: prompt };
         this.registry.setMode(mode);
         this.save();
     }
@@ -322,6 +361,8 @@ export class Session {
     /** Reset the stopped flag for a new conversation */
     resetStopped() {
         this.stopped = false;
+        // Create new AbortController for next conversation
+        this.abortController = new AbortController();
     }
     async chat(userPrompt) {
         const bus = getGlobalEventBus();
@@ -334,6 +375,8 @@ export class Session {
         this.turnInputTokens = 0;
         this.turnOutputTokens = 0;
         this.turnApiCalls = 0;
+        this.turnCacheHitTokens = 0;
+        this.turnCacheMissTokens = 0;
         let iterations = 0;
         const maxIterations = 30;
         // Reset stopped flag for new conversation
@@ -361,171 +404,214 @@ export class Session {
             bus.emit(EventChannels.TURN_START, { prompt: userPrompt, iteration: iterations });
             bus.emit(EventChannels.LLM_STREAM_START, { iteration: iterations });
             const stream = this.provider.chat(this.messages, this.registry.getDefinitions(), this.abortController.signal);
-            for await (const chunk of stream) {
-                if (chunk.reasoning_content) {
-                    reasoningContent = chunk.reasoning_content;
-                    // Stream reasoning content in real-time (only when no text in same chunk)
-                    if (!chunk.text) {
-                        // Emit thinking via EventBus for Web UI
-                        bus.emit(EventChannels.THINKING, { text: chunk.reasoning_content });
-                        if (!reasoningOutput) {
-                            reasoningOutput = true;
-                            reasoningLineStart = true;
-                            if (!out?.suppressToolOutput) {
-                                writeOut(thinkTopBorder(), out);
-                            }
-                        }
-                        // Terminal display with box drawing (skip in Web UI mode, handled by EventBus)
-                        if (!out?.suppressToolOutput) {
-                            // Track column position on current line for wrapping
-                            let thinkCol = 0;
-                            // Handle newlines in streamed content - add left border on each new line
-                            // Also manually wrap long lines so wrapped lines keep the │ prefix.
-                            let remaining = chunk.reasoning_content;
-                            const maxContentWidth = termWidth() - THINK_PREFIX_WIDTH;
-                            while (remaining.length > 0) {
-                                if (reasoningLineStart) {
-                                    writeOut(`  ${GY}│${RS}${TH}`, out);
-                                    reasoningLineStart = false;
-                                    thinkCol = 0;
+            try {
+                for await (const chunk of stream) {
+                    if (chunk.reasoning_content) {
+                        reasoningContent = chunk.reasoning_content;
+                        // Stream reasoning content in real-time (only when no text in same chunk)
+                        if (!chunk.text) {
+                            // Emit thinking via EventBus for Web UI
+                            bus.emit(EventChannels.THINKING, { text: chunk.reasoning_content });
+                            if (!reasoningOutput) {
+                                reasoningOutput = true;
+                                reasoningLineStart = true;
+                                if (!out?.suppressToolOutput) {
+                                    writeOut(thinkTopBorder(), out);
                                 }
-                                const nlIdx = remaining.indexOf('\n');
-                                if (nlIdx === -1) {
-                                    // No newline — write as much as fits on current line, wrap if needed
-                                    while (remaining.length > 0) {
-                                        const segWidth = visibleWidth(remaining);
+                            }
+                            // Terminal display with box drawing (skip in Web UI mode, handled by EventBus)
+                            if (!out?.suppressToolOutput) {
+                                // Track column position on current line for wrapping
+                                let thinkCol = 0;
+                                // Handle newlines in streamed content - add left border on each new line
+                                // Also manually wrap long lines so wrapped lines keep the │ prefix.
+                                let remaining = chunk.reasoning_content;
+                                const maxContentWidth = termWidth() - THINK_PREFIX_WIDTH;
+                                while (remaining.length > 0) {
+                                    if (reasoningLineStart) {
+                                        writeOut(`  ${GY}│${RS}${TH}`, out);
+                                        reasoningLineStart = false;
+                                        thinkCol = 0;
+                                    }
+                                    const nlIdx = remaining.indexOf('\n');
+                                    if (nlIdx === -1) {
+                                        // No newline — write as much as fits on current line, wrap if needed
+                                        while (remaining.length > 0) {
+                                            const segWidth = visibleWidth(remaining);
+                                            const avail = maxContentWidth - thinkCol;
+                                            if (segWidth <= avail) {
+                                                // Fits entirely on current line
+                                                writeOut(remaining, out);
+                                                thinkCol += segWidth;
+                                                remaining = '';
+                                            }
+                                            else if (avail <= 0) {
+                                                // Current line is full, wrap to next
+                                                writeOut(`${RS}\n`, out);
+                                                writeOut(`  ${GY}│${RS}${TH}`, out);
+                                                thinkCol = 0;
+                                            }
+                                            else {
+                                                // Write first part that fits, then wrap
+                                                // Find character boundary that fits within avail
+                                                let cut = avail;
+                                                while (cut > 0 && visibleWidth(remaining.slice(0, cut)) > avail)
+                                                    cut--;
+                                                if (cut <= 0)
+                                                    cut = 1;
+                                                writeOut(remaining.slice(0, cut), out);
+                                                writeOut(`${RS}\n`, out);
+                                                writeOut(`  ${GY}│${RS}${TH}`, out);
+                                                thinkCol = 0;
+                                                remaining = remaining.slice(cut);
+                                            }
+                                        }
+                                    }
+                                    else {
+                                        // Has newline — process the segment up to newline
+                                        const segment = remaining.slice(0, nlIdx);
+                                        const segWidth = visibleWidth(segment);
                                         const avail = maxContentWidth - thinkCol;
                                         if (segWidth <= avail) {
-                                            // Fits entirely on current line
-                                            writeOut(remaining, out);
-                                            thinkCol += segWidth;
-                                            remaining = '';
-                                        }
-                                        else if (avail <= 0) {
-                                            // Current line is full, wrap to next
+                                            // Segment fits on current line
+                                            writeOut(segment, out);
                                             writeOut(`${RS}\n`, out);
-                                            writeOut(`  ${GY}│${RS}${TH}`, out);
+                                            reasoningLineStart = true;
                                             thinkCol = 0;
                                         }
                                         else {
-                                            // Write first part that fits, then wrap
-                                            // Find character boundary that fits within avail
-                                            let cut = avail;
-                                            while (cut > 0 && visibleWidth(remaining.slice(0, cut)) > avail)
-                                                cut--;
-                                            if (cut <= 0)
-                                                cut = 1;
-                                            writeOut(remaining.slice(0, cut), out);
+                                            // Segment too long — write what fits, wrap, then rest
+                                            let rest = segment;
+                                            // Write remainder of current line
+                                            if (avail > 0) {
+                                                let cut = avail;
+                                                while (cut > 0 && visibleWidth(rest.slice(0, cut)) > avail)
+                                                    cut--;
+                                                if (cut <= 0)
+                                                    cut = 1;
+                                                writeOut(rest.slice(0, cut), out);
+                                                rest = rest.slice(cut);
+                                            }
                                             writeOut(`${RS}\n`, out);
-                                            writeOut(`  ${GY}│${RS}${TH}`, out);
+                                            reasoningLineStart = true;
                                             thinkCol = 0;
-                                            remaining = remaining.slice(cut);
-                                        }
-                                    }
-                                }
-                                else {
-                                    // Has newline — process the segment up to newline
-                                    const segment = remaining.slice(0, nlIdx);
-                                    const segWidth = visibleWidth(segment);
-                                    const avail = maxContentWidth - thinkCol;
-                                    if (segWidth <= avail) {
-                                        // Segment fits on current line
-                                        writeOut(segment, out);
-                                        writeOut(`${RS}\n`, out);
-                                        reasoningLineStart = true;
-                                        thinkCol = 0;
-                                    }
-                                    else {
-                                        // Segment too long — write what fits, wrap, then rest
-                                        let rest = segment;
-                                        // Write remainder of current line
-                                        if (avail > 0) {
-                                            let cut = avail;
-                                            while (cut > 0 && visibleWidth(rest.slice(0, cut)) > avail)
-                                                cut--;
-                                            if (cut <= 0)
-                                                cut = 1;
-                                            writeOut(rest.slice(0, cut), out);
-                                            rest = rest.slice(cut);
-                                        }
-                                        writeOut(`${RS}\n`, out);
-                                        reasoningLineStart = true;
-                                        thinkCol = 0;
-                                        // Write rest of segment on continuation line(s)
-                                        if (rest.length > 0) {
-                                            writeOut(`  ${GY}│${RS}${TH}`, out);
-                                            reasoningLineStart = false;
-                                            while (rest.length > 0) {
-                                                const rw = visibleWidth(rest);
-                                                if (rw <= maxContentWidth) {
-                                                    writeOut(rest, out);
-                                                    thinkCol = rw;
-                                                    rest = '';
-                                                }
-                                                else {
-                                                    let cut = maxContentWidth;
-                                                    while (cut > 0 && visibleWidth(rest.slice(0, cut)) > maxContentWidth)
-                                                        cut--;
-                                                    if (cut <= 0)
-                                                        cut = 1;
-                                                    writeOut(rest.slice(0, cut), out);
-                                                    writeOut(`${RS}\n`, out);
-                                                    writeOut(`  ${GY}│${RS}${TH}`, out);
-                                                    rest = rest.slice(cut);
+                                            // Write rest of segment on continuation line(s)
+                                            if (rest.length > 0) {
+                                                writeOut(`  ${GY}│${RS}${TH}`, out);
+                                                reasoningLineStart = false;
+                                                while (rest.length > 0) {
+                                                    const rw = visibleWidth(rest);
+                                                    if (rw <= maxContentWidth) {
+                                                        writeOut(rest, out);
+                                                        thinkCol = rw;
+                                                        rest = '';
+                                                    }
+                                                    else {
+                                                        let cut = maxContentWidth;
+                                                        while (cut > 0 && visibleWidth(rest.slice(0, cut)) > maxContentWidth)
+                                                            cut--;
+                                                        if (cut <= 0)
+                                                            cut = 1;
+                                                        writeOut(rest.slice(0, cut), out);
+                                                        writeOut(`${RS}\n`, out);
+                                                        writeOut(`  ${GY}│${RS}${TH}`, out);
+                                                        rest = rest.slice(cut);
+                                                    }
                                                 }
                                             }
+                                            writeOut(`${RS}\n`, out);
+                                            reasoningLineStart = true;
+                                            thinkCol = 0;
                                         }
-                                        writeOut(`${RS}\n`, out);
-                                        reasoningLineStart = true;
-                                        thinkCol = 0;
+                                        remaining = remaining.slice(nlIdx + 1);
                                     }
-                                    remaining = remaining.slice(nlIdx + 1);
                                 }
                             }
                         }
                     }
-                }
-                if (chunk.type === 'text' && chunk.text) {
-                    if (reasoningOutput) {
-                        bus.emit(EventChannels.THINKING_END, {});
-                        if (!out?.suppressToolOutput) {
-                            writeOut(`${RS}\n`, out);
-                            writeOut(thinkBottomBorder(), out);
+                    if (chunk.type === 'text' && chunk.text) {
+                        if (reasoningOutput) {
+                            bus.emit(EventChannels.THINKING_END, {});
+                            if (!out?.suppressToolOutput) {
+                                writeOut(`${RS}\n`, out);
+                                writeOut(thinkBottomBorder(), out);
+                            }
+                            reasoningOutput = false;
+                            reasoningLineStart = false;
                         }
-                        reasoningOutput = false;
-                        reasoningLineStart = false;
+                        fullResponse += chunk.text;
+                        writeOut(chunk.text, out);
                     }
-                    fullResponse += chunk.text;
-                    writeOut(chunk.text, out);
-                }
-                else if (chunk.type === 'tool_use' && chunk.tool_call) {
-                    toolCalls.push(chunk.tool_call);
-                }
-                else if (chunk.type === 'complete') {
-                    if (chunk.usage) {
-                        this.turnInputTokens += chunk.usage.input_tokens;
-                        this.turnOutputTokens += chunk.usage.output_tokens;
-                        this.totalInputTokens += chunk.usage.input_tokens;
-                        this.totalOutputTokens += chunk.usage.output_tokens;
+                    else if (chunk.type === 'tool_use' && chunk.tool_call) {
+                        toolCalls.push(chunk.tool_call);
                     }
-                    if (chunk.finish_reason === 'stop' || chunk.finish_reason === 'end_turn') {
-                        if (toolCalls.length === 0) {
-                            const finalAssistantMsg = {
-                                role: 'assistant',
-                                content: fullResponse || null,
-                                reasoning_content: reasoningContent,
-                            };
-                            this.messages.push(finalAssistantMsg);
-                            printTokenStats(this.turnInputTokens, this.turnOutputTokens, this.totalInputTokens, this.totalOutputTokens, this.turnApiCalls, this.totalApiCalls, out);
-                            writeOut('\n\n', out);
-                            saveTokenUsage(this.config.cwd, this.turnInputTokens, this.turnOutputTokens, this.turnApiCalls);
-                            bus.emit(EventChannels.TURN_END, { iterations, toolCallCount: 0 });
-                            this.save();
-                            return;
+                    else if (chunk.type === 'complete') {
+                        if (chunk.usage) {
+                            this.turnInputTokens += chunk.usage.input_tokens;
+                            this.turnOutputTokens += chunk.usage.output_tokens;
+                            this.totalInputTokens += chunk.usage.input_tokens;
+                            this.totalOutputTokens += chunk.usage.output_tokens;
+                            // Accumulate DeepSeek cache hit/miss tokens
+                            if (chunk.usage.prompt_cache_hit_tokens != null) {
+                                this.turnCacheHitTokens += chunk.usage.prompt_cache_hit_tokens;
+                                this.totalCacheHitTokens += chunk.usage.prompt_cache_hit_tokens;
+                            }
+                            if (chunk.usage.prompt_cache_miss_tokens != null) {
+                                this.turnCacheMissTokens += chunk.usage.prompt_cache_miss_tokens;
+                                this.totalCacheMissTokens += chunk.usage.prompt_cache_miss_tokens;
+                            }
+                        }
+                        if (chunk.finish_reason === 'stop' || chunk.finish_reason === 'end_turn') {
+                            if (toolCalls.length === 0) {
+                                const finalAssistantMsg = {
+                                    role: 'assistant',
+                                    content: fullResponse || null,
+                                    reasoning_content: reasoningContent,
+                                };
+                                this.messages.push(finalAssistantMsg);
+                                printTokenStats(this.turnInputTokens, this.turnOutputTokens, this.totalInputTokens, this.totalOutputTokens, this.turnApiCalls, this.totalApiCalls, out, this.turnCacheHitTokens, this.turnCacheMissTokens, this.totalCacheHitTokens, this.totalCacheMissTokens);
+                                writeOut('\n\n', out);
+                                saveTokenUsage(this.config.cwd, this.turnInputTokens, this.turnOutputTokens, this.turnApiCalls);
+                                bus.emit(EventChannels.TURN_END, { iterations, toolCallCount: 0 });
+                                this.save();
+                                return;
+                            }
                         }
                     }
                 }
             }
+            catch (e) {
+                const errMsg = fmtErr(e);
+                const partialContent = fullResponse ? fullResponse.slice(0, 500) : '(empty)';
+                if (!out?.suppressToolOutput) {
+                    writeOut(`\n${RE}Stream error:${RS} ${errMsg}`, out);
+                    writeOut(`\n  ${GY}┃${RS} Partial response: ${partialContent}\n`, out);
+                }
+                console.error('[session] Stream error:', errMsg, '| Partial response:', partialContent);
+                if (reasoningOutput) {
+                    bus.emit(EventChannels.THINKING_END, {});
+                    if (!out?.suppressToolOutput) {
+                        writeOut(`${RS}\n`, out);
+                        writeOut(thinkBottomBorder(), out);
+                    }
+                }
+                bus.emit(EventChannels.LLM_STREAM_END, { iteration: iterations, toolCallCount: 0 });
+                bus.emit(EventChannels.TURN_END, { iterations, toolCallCount: 0 });
+                // If there are pending toolCalls that weren't executed due to abort,
+                // add an assistant message so the model knows they weren't executed
+                if (toolCalls.length > 0) {
+                    const interruptedMsg = {
+                        role: 'assistant',
+                        content: null,
+                        tool_calls: toolCalls,
+                        reasoning_content: reasoningContent,
+                    };
+                    this.messages.push(interruptedMsg);
+                }
+                saveTokenUsage(this.config.cwd, this.turnInputTokens, this.turnOutputTokens, this.turnApiCalls);
+                this.save();
+                return;
+            }
             bus.emit(EventChannels.LLM_STREAM_END, {
                 iteration: iterations,
                 toolCallCount: toolCalls.length,
@@ -548,7 +634,7 @@ export class Session {
                         reasoning_content: reasoningContent,
                     };
                     this.messages.push(finalAssistantMsg);
-                    printTokenStats(this.turnInputTokens, this.turnOutputTokens, this.totalInputTokens, this.totalOutputTokens, this.turnApiCalls, this.totalApiCalls, out);
+                    printTokenStats(this.turnInputTokens, this.turnOutputTokens, this.totalInputTokens, this.totalOutputTokens, this.turnApiCalls, this.totalApiCalls, out, this.turnCacheHitTokens, this.turnCacheMissTokens, this.totalCacheHitTokens, this.totalCacheMissTokens);
                     writeOut('\n\n', out);
                 }
                 saveTokenUsage(this.config.cwd, this.turnInputTokens, this.turnOutputTokens, this.turnApiCalls);
@@ -566,7 +652,7 @@ export class Session {
             this.save();
             // ── User confirmation for write-type tool calls ──
             if (!this.config.autoApprove && this.output?.confirmTool && toolCalls.length > 0) {
-                const writeTools = ['edit', 'bash', 'write_plan', 'exec', 'install_skill'];
+                const writeTools = ['edit', 'bash', 'write_plan', 'install_skill'];
                 const needsConfirm = toolCalls.filter(tc => writeTools.includes(tc.name));
                 if (needsConfirm.length > 0) {
                     const approved = await this.output.confirmTool(needsConfirm);
@@ -583,9 +669,20 @@ export class Session {
                     }
                 }
             }
-            for (const tc of toolCalls) {
+            for (let i = 0; i < toolCalls.length; i++) {
+                const tc = toolCalls[i];
                 // Check if stop was requested after each tool call
                 if (this.isStopped()) {
+                    // Add assistant message with remaining tool_calls so model knows they weren't executed
+                    const remainingToolCalls = toolCalls.slice(i);
+                    if (remainingToolCalls.length > 0) {
+                        const interruptedMsg = {
+                            role: 'assistant',
+                            content: null,
+                            tool_calls: remainingToolCalls,
+                        };
+                        this.messages.push(interruptedMsg);
+                    }
                     bus.emit(EventChannels.TURN_END, { iterations, toolCallCount: toolCalls.length });
                     this.save();
                     return;
@@ -629,7 +726,7 @@ export class Session {
             }
         }
         if (iterations >= maxIterations) {
-            printTokenStats(this.turnInputTokens, this.turnOutputTokens, this.totalInputTokens, this.totalOutputTokens, this.turnApiCalls, this.totalApiCalls, out);
+            printTokenStats(this.turnInputTokens, this.turnOutputTokens, this.totalInputTokens, this.totalOutputTokens, this.turnApiCalls, this.totalApiCalls, out, this.turnCacheHitTokens, this.turnCacheMissTokens, this.totalCacheHitTokens, this.totalCacheMissTokens);
             writeOut('\nAgent reached maximum iterations. Stopping.\n', out);
         }
         saveTokenUsage(this.config.cwd, this.turnInputTokens, this.turnOutputTokens, this.turnApiCalls);