lonny-agent 0.2.3 → 0.2.6

package/src/agent/session.ts

@@ -5,6 +5,7 @@ import * as path from 'node:path'
 import type { Config } from '../config/index.js'
 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 type { ToolCall, ToolResult } from '../tools/types.js'
 import { compact, estimateMessagesTokens, shouldCompact } from './compaction.js'
@@ -24,6 +25,8 @@ interface SessionData {
   totalInputTokens: number
   totalOutputTokens: number
   totalApiCalls: number
+  totalCacheHitTokens?: number
+  totalCacheMissTokens?: number
   mode: 'code' | 'plan' | 'ask'
   model: string
   provider: string
@@ -221,13 +224,36 @@ function printTokenStats(
   turnApi: number,
   totalApi: number,
   output?: SessionOutput,
+  turnCacheHit?: number,
+  turnCacheMiss?: number,
+  totalCacheHit?: number,
+  totalCacheMiss?: number,
 ): void {
   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)
 }
 
@@ -258,6 +284,10 @@ export class Session {
   turnOutputTokens: number = 0
   turnApiCalls: number = 0
   totalApiCalls: number = 0
+  turnCacheHitTokens: number = 0
+  turnCacheMissTokens: number = 0
+  totalCacheHitTokens: number = 0
+  totalCacheMissTokens: number = 0
   private stopped: boolean = false
   private abortController: AbortController | null = null
 
@@ -291,7 +321,17 @@ export class Session {
       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 */
+  private initSystemPrompt(config: Config): void {
+    buildSystemPrompt(config).then(prompt => {
+      this.messages = [{ role: 'system', content: prompt }]
+    })
   }
 
   /** Persist the current session to ~/.lonny/sessions/ */
@@ -305,6 +345,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,
@@ -314,7 +356,7 @@ export class Session {
   }
 
   /** Try to load a saved session for the given cwd. Returns null if none exists. */
-  static load(config: Config, output?: SessionOutput): Session | null {
+  static async load(config: Config, output?: SessionOutput): Promise<Session | null> {
     const filePath = getSessionFilePath(config.cwd)
     let data: SessionData
     try {
@@ -340,12 +382,15 @@ export class Session {
       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
   }
 
@@ -359,9 +404,10 @@ export class Session {
     }
   }
 
-  setMode(mode: 'code' | 'plan' | 'ask'): void {
+  async setMode(mode: 'code' | 'plan' | 'ask'): Promise<void> {
     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()
   }
@@ -381,6 +427,8 @@ export class Session {
   /** Reset the stopped flag for a new conversation */
   resetStopped(): void {
     this.stopped = false
+    // Create new AbortController for next conversation
+    this.abortController = new AbortController()
   }
 
   async chat(userPrompt: string): Promise<void> {
@@ -395,6 +443,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
@@ -433,171 +483,224 @@ export class Session {
         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)
-        } 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
-          }
-          if (chunk.finish_reason === 'stop' || chunk.finish_reason === 'end_turn') {
-            if (toolCalls.length === 0) {
-              const finalAssistantMsg: LLMMessage = {
-                role: 'assistant',
-                content: fullResponse || null,
-                reasoning_content: reasoningContent,
+            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
+              // 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
               }
-              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
             }
+            if (chunk.finish_reason === 'stop' || chunk.finish_reason === 'end_turn') {
+              if (toolCalls.length === 0) {
+                const finalAssistantMsg: LLMMessage = {
+                  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: LLMMessage = {
+            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, {
@@ -632,6 +735,10 @@ export class Session {
             this.turnApiCalls,
             this.totalApiCalls,
             out,
+            this.turnCacheHitTokens,
+            this.turnCacheMissTokens,
+            this.totalCacheHitTokens,
+            this.totalCacheMissTokens,
           )
           writeOut('\n\n', out)
         }
@@ -657,7 +764,7 @@ export class Session {
 
       // ── 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)
@@ -676,9 +783,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: LLMMessage = {
+              role: 'assistant',
+              content: null,
+              tool_calls: remainingToolCalls,
+            }
+            this.messages.push(interruptedMsg)
+          }
           bus.emit(EventChannels.TURN_END, { iterations, toolCallCount: toolCalls.length })
           this.save()
           return
@@ -736,6 +854,10 @@ export class Session {
         this.turnApiCalls,
         this.totalApiCalls,
         out,
+        this.turnCacheHitTokens,
+        this.turnCacheMissTokens,
+        this.totalCacheHitTokens,
+        this.totalCacheMissTokens,
       )
       writeOut('\nAgent reached maximum iterations. Stopping.\n', out)
     }