lonny-agent 0.2.3 → 0.2.4

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'
@@ -291,7 +292,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/ */
@@ -314,7 +325,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,7 +351,8 @@ 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
@@ -359,9 +371,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 +394,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> {
@@ -433,171 +448,211 @@ 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
+            }
+            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,
+                )
+                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
               }
-              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
             }
           }
         }
+      } 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, {
@@ -676,9 +731,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

package/src/tools/__tests__/edit.test.ts

@@ -295,8 +295,8 @@ describe('edit tool', () => {
       expect(r.success).toBe(true)
       // Should contain green ANSI code for added lines
       expect(r.output).toContain('\x1b[38;2;0;200;100m') // green
-      expect(r.output).toContain('+ hello')
-      expect(r.output).toContain('+ world')
+      expect(r.output).toContain('hello')
+      expect(r.output).toContain('world')
       // Should NOT contain red ANSI code (no removed lines)
       expect(r.output).not.toContain('\x1b[38;2;255;80;80m')
       expect(r.output).toContain('Created')
@@ -315,10 +315,10 @@ describe('edit tool', () => {
       expect(r.success).toBe(true)
       // Should contain red ANSI code for removed content
       expect(r.output).toContain('\x1b[38;2;255;80;80m')
-      expect(r.output).toContain('- line two')
+      expect(r.output).toContain('line two')
       // Should contain green ANSI code for added content
       expect(r.output).toContain('\x1b[38;2;0;200;100m')
-      expect(r.output).toContain('+ line TWO')
+      expect(r.output).toContain('line TWO')
       expect(r.output).toContain('Edited')
     })
 
@@ -333,12 +333,12 @@ describe('edit tool', () => {
         ],
       })
       expect(r.success).toBe(true)
-      // Removed lines
-      expect(r.output).toContain('- line one')
-      expect(r.output).toContain('- line TWO')
-      // Added lines
-      expect(r.output).toContain('+ line 1')
-      expect(r.output).toContain('+ line 2')
+      // Removed lines (red)
+      expect(r.output).toContain('\x1b[38;2;255;80;80mline one')
+      expect(r.output).toContain('\x1b[38;2;255;80;80mline TWO')
+      // Added lines (green)
+      expect(r.output).toContain('\x1b[38;2;0;200;100mline 1')
+      expect(r.output).toContain('\x1b[38;2;0;200;100mline 2')
     })
 
     it('handles CRLF in old_string (Windows compatibility)', async () => {
@@ -357,8 +357,8 @@ describe('edit tool', () => {
       const content = fs.readFileSync(path.join(tmpDir, 'crlf-test.txt'), 'utf8')
       expect(content).toContain('B')
       // Should show the normalized diff (with \\n, not \\r\\n)
-      expect(r.output).toContain('- b')
-      expect(r.output).toContain('+ B')
+      expect(r.output).toContain('\x1b[38;2;255;80;80mb')
+      expect(r.output).toContain('\x1b[38;2;0;200;100mB')
     })
 
     it('does not show empty red line when old_string is empty', async () => {
@@ -366,8 +366,8 @@ describe('edit tool', () => {
         edits: [{ file_path: 'empty-old.txt', old_string: '', new_string: 'only added' }],
       })
       expect(r.success).toBe(true)
-      // Should have green + lines
-      expect(r.output).toContain('+ only added')
+      // Should have green colored line
+      expect(r.output).toContain('\x1b[38;2;0;200;100monly added')
       // Count red-start markers — should be 0 (no removed content)
       const redCount = (r.output.match(/\x1b\[38;2;255;80;80m/g) || []).length
       expect(redCount).toBe(0)