lonny-agent 0.2.4 → 0.2.6

package/src/agent/providers/ollama.ts

@@ -1,186 +1,186 @@
-import { ToolCall, type ToolDefinition } from '../../tools/types.js'
-import type { LLMChunk, LLMMessage, LLMProvider } from '../llm.js'
-
-interface OllamaTool {
-  type: 'function'
-  function: {
-    name: string
-    description: string
-    parameters: Record<string, unknown>
-  }
-}
-
-interface OllamaMessage {
-  role: 'system' | 'user' | 'assistant' | 'tool'
-  content: string
-  tool_calls?: {
-    function: {
-      name: string
-      arguments: string
-    }
-  }[]
-}
-
-interface OllamaResponse {
-  model: string
-  created_at: string
-  message: OllamaMessage
-  done: boolean
-  done_reason?: string
-  prompt_eval_count?: number
-  eval_count?: number
-}
-
-export class OllamaProvider implements LLMProvider {
-  private baseUrl: string
-  private model: string
-
-  constructor(_apiKey: string, baseURL?: string, model?: string) {
-    this.baseUrl = baseURL || 'http://localhost:11434'
-    this.model = model || 'llama3.2'
-  }
-
-  async *chat(
-    messages: LLMMessage[],
-    tools: ToolDefinition[],
-    signal?: AbortSignal,
-  ): AsyncGenerator<LLMChunk> {
-    // Build Ollama-format messages
-    const ollamaMessages: OllamaMessage[] = messages.map(m => {
-      if (m.role === 'system') {
-        return { role: 'system', content: m.content || '' }
-      }
-      if (m.role === 'user') {
-        return { role: 'user', content: m.content || '' }
-      }
-      if (m.role === 'assistant') {
-        if (m.tool_calls && m.tool_calls.length > 0) {
-          return {
-            role: 'assistant',
-            content: m.content || '',
-            tool_calls: m.tool_calls.map(tc => ({
-              function: {
-                name: tc.name,
-                arguments: JSON.stringify(tc.input),
-              },
-            })),
-          }
-        }
-        return { role: 'assistant', content: m.content || '' }
-      }
-      if (m.role === 'tool') {
-        return { role: 'tool', content: m.content || '' }
-      }
-      return { role: 'user', content: '' }
-    })
-
-    // Build tools
-    const ollamaTools: OllamaTool[] | undefined =
-      tools.length > 0
-        ? tools.map(t => {
-            const properties: Record<string, unknown> = {}
-            for (const [key, param] of Object.entries(t.parameters)) {
-              const { required: _, ...rest } = param
-              properties[key] = rest
-            }
-            return {
-              type: 'function' as const,
-              function: {
-                name: t.name,
-                description: t.description,
-                parameters: {
-                  type: 'object',
-                  properties,
-                  required: Object.entries(t.parameters)
-                    .filter(([, v]) => v.required)
-                    .map(([k]) => k),
-                },
-              },
-            }
-          })
-        : undefined
-
-    const body: Record<string, unknown> = {
-      model: this.model,
-      messages: ollamaMessages,
-      stream: true,
-    }
-    if (ollamaTools && ollamaTools.length > 0) {
-      body.tools = ollamaTools
-    }
-
-    const response = await fetch(`${this.baseUrl}/api/chat`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      signal,
-      body: JSON.stringify(body),
-    })
-
-    if (!response.ok) {
-      const errText = await response.text()
-      throw new Error(`Ollama API error (${response.status}): ${errText}`)
-    }
-
-    const reader = response.body?.getReader()
-    if (!reader) throw new Error('No response body')
-
-    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.trim()) continue
-        try {
-          const chunk = JSON.parse(line) as OllamaResponse
-
-          if (chunk.message?.content) {
-            yield { type: 'text', text: chunk.message.content }
-          }
-
-          if (chunk.message?.tool_calls) {
-            for (const tc of chunk.message.tool_calls) {
-              let input: Record<string, unknown> = {}
-              try {
-                input = JSON.parse(tc.function.arguments || '{}')
-              } catch {
-                console.error(
-                  '[ollama] Failed to parse tool_call arguments:',
-                  tc.function.arguments,
-                )
-                input = {}
-              }
-              yield {
-                type: 'tool_use',
-                tool_call: {
-                  id: `ollama-${tc.function.name}-${Date.now()}`,
-                  name: tc.function.name,
-                  input,
-                },
-              }
-            }
-          }
-
-          if (chunk.done) {
-            yield {
-              type: 'complete',
-              finish_reason: chunk.done_reason || 'stop',
-              usage: {
-                input_tokens: chunk.prompt_eval_count ?? 0,
-                output_tokens: chunk.eval_count ?? 0,
-              },
-            }
-          }
-        } catch {
-          console.error('[ollama] Failed to parse stream line:', line)
-        }
-      }
-    }
-  }
-}
+import { ToolCall, type ToolDefinition } from '../../tools/types.js'
+import type { LLMChunk, LLMMessage, LLMProvider } from '../llm.js'
+
+interface OllamaTool {
+  type: 'function'
+  function: {
+    name: string
+    description: string
+    parameters: Record<string, unknown>
+  }
+}
+
+interface OllamaMessage {
+  role: 'system' | 'user' | 'assistant' | 'tool'
+  content: string
+  tool_calls?: {
+    function: {
+      name: string
+      arguments: string
+    }
+  }[]
+}
+
+interface OllamaResponse {
+  model: string
+  created_at: string
+  message: OllamaMessage
+  done: boolean
+  done_reason?: string
+  prompt_eval_count?: number
+  eval_count?: number
+}
+
+export class OllamaProvider implements LLMProvider {
+  private baseUrl: string
+  private model: string
+
+  constructor(_apiKey: string, baseURL?: string, model?: string) {
+    this.baseUrl = baseURL || 'http://localhost:11434'
+    this.model = model || 'llama3.2'
+  }
+
+  async *chat(
+    messages: LLMMessage[],
+    tools: ToolDefinition[],
+    signal?: AbortSignal,
+  ): AsyncGenerator<LLMChunk> {
+    // Build Ollama-format messages
+    const ollamaMessages: OllamaMessage[] = messages.map(m => {
+      if (m.role === 'system') {
+        return { role: 'system', content: m.content || '' }
+      }
+      if (m.role === 'user') {
+        return { role: 'user', content: m.content || '' }
+      }
+      if (m.role === 'assistant') {
+        if (m.tool_calls && m.tool_calls.length > 0) {
+          return {
+            role: 'assistant',
+            content: m.content || '',
+            tool_calls: m.tool_calls.map(tc => ({
+              function: {
+                name: tc.name,
+                arguments: JSON.stringify(tc.input),
+              },
+            })),
+          }
+        }
+        return { role: 'assistant', content: m.content || '' }
+      }
+      if (m.role === 'tool') {
+        return { role: 'tool', content: m.content || '' }
+      }
+      return { role: 'user', content: '' }
+    })
+
+    // Build tools
+    const ollamaTools: OllamaTool[] | undefined =
+      tools.length > 0
+        ? tools.map(t => {
+            const properties: Record<string, unknown> = {}
+            for (const [key, param] of Object.entries(t.parameters)) {
+              const { required: _, ...rest } = param
+              properties[key] = rest
+            }
+            return {
+              type: 'function' as const,
+              function: {
+                name: t.name,
+                description: t.description,
+                parameters: {
+                  type: 'object',
+                  properties,
+                  required: Object.entries(t.parameters)
+                    .filter(([, v]) => v.required)
+                    .map(([k]) => k),
+                },
+              },
+            }
+          })
+        : undefined
+
+    const body: Record<string, unknown> = {
+      model: this.model,
+      messages: ollamaMessages,
+      stream: true,
+    }
+    if (ollamaTools && ollamaTools.length > 0) {
+      body.tools = ollamaTools
+    }
+
+    const response = await fetch(`${this.baseUrl}/api/chat`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      signal,
+      body: JSON.stringify(body),
+    })
+
+    if (!response.ok) {
+      const errText = await response.text()
+      throw new Error(`Ollama API error (${response.status}): ${errText}`)
+    }
+
+    const reader = response.body?.getReader()
+    if (!reader) throw new Error('No response body')
+
+    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.trim()) continue
+        try {
+          const chunk = JSON.parse(line) as OllamaResponse
+
+          if (chunk.message?.content) {
+            yield { type: 'text', text: chunk.message.content }
+          }
+
+          if (chunk.message?.tool_calls) {
+            for (const tc of chunk.message.tool_calls) {
+              let input: Record<string, unknown> = {}
+              try {
+                input = JSON.parse(tc.function.arguments || '{}')
+              } catch {
+                console.error(
+                  '[ollama] Failed to parse tool_call arguments:',
+                  tc.function.arguments,
+                )
+                input = {}
+              }
+              yield {
+                type: 'tool_use',
+                tool_call: {
+                  id: `ollama-${tc.function.name}-${Date.now()}`,
+                  name: tc.function.name,
+                  input,
+                },
+              }
+            }
+          }
+
+          if (chunk.done) {
+            yield {
+              type: 'complete',
+              finish_reason: chunk.done_reason || 'stop',
+              usage: {
+                input_tokens: chunk.prompt_eval_count ?? 0,
+                output_tokens: chunk.eval_count ?? 0,
+              },
+            }
+          }
+        } catch {
+          console.error('[ollama] Failed to parse stream line:', line)
+        }
+      }
+    }
+  }
+}

package/src/agent/providers/openai.ts

@@ -21,6 +21,38 @@ interface ExtendedCreateParams {
   enable_cache?: boolean
 }
 
+/** Try to parse JSON, and attempt to repair common issues like unescaped quotes */
+function tryParseJSON(input: string): Record<string, unknown> | null {
+  try {
+    return JSON.parse(input)
+  } catch {
+    // Try to repair common JSON issues from LLM output
+    let repaired = input
+
+    // Fix unescaped quotes in string values:
+    // Pattern: key="unquoted text" -> key="escaped text"
+    // This regex finds ="<not properly escaped>" and adds escaping
+    // It handles: ="<content with spaces and 中文">
+    repaired = repaired.replace(/= "([^"\\]*(?:\\.[^"\\]*)*)"/g, (match, content) => {
+      // Escape any unescaped quotes within the content
+      const escaped = content.replace(/(?<!\\)"/g, '\\"')
+      return `= "${escaped}"`
+    })
+
+    // Also try escaping quotes after @ (for @click="...")
+    repaired = repaired.replace(/@(\w+)="([^"\\]*(?:\\.[^"\\]*)*)"/g, (match, attr, content) => {
+      const escaped = content.replace(/(?<!\\)"/g, '\\"')
+      return `@${attr}="${escaped}"`
+    })
+
+    try {
+      return JSON.parse(repaired)
+    } catch {
+      return null
+    }
+  }
+}
+
 export class OpenAIProvider implements LLMProvider {
   private client: OpenAI
   private model: string
@@ -146,7 +178,14 @@ export class OpenAIProvider implements LLMProvider {
     } | null = null
     let fullText = ''
     let reasoningContent: string | undefined
-    let lastUsage: { prompt_tokens?: number; completion_tokens?: number } | undefined
+    let lastUsage:
+      | {
+          prompt_tokens?: number
+          completion_tokens?: number
+          prompt_cache_hit_tokens?: number
+          prompt_cache_miss_tokens?: number
+        }
+      | undefined
 
     // Track a pending "complete" yield — OpenAI sends finish_reason in a content
     // chunk but sends usage in a *separate final chunk* with no choices/delta.
@@ -159,7 +198,15 @@ export class OpenAIProvider implements LLMProvider {
     for await (const chunk of stream) {
       // Capture usage info if present (may come in a chunk without choices)
       // OpenAI uses prompt_tokens/completion_tokens; map to our input_tokens/output_tokens
-      const rawChunk = chunk as { usage?: { prompt_tokens?: number; completion_tokens?: number } }
+      // DeepSeek also returns prompt_cache_hit_tokens & prompt_cache_miss_tokens
+      const rawChunk = chunk as {
+        usage?: {
+          prompt_tokens?: number
+          completion_tokens?: number
+          prompt_cache_hit_tokens?: number
+          prompt_cache_miss_tokens?: number
+        }
+      }
       if (rawChunk.usage) {
         lastUsage = rawChunk.usage
         // If we have a pending complete, yield it now with usage
@@ -171,6 +218,8 @@ export class OpenAIProvider implements LLMProvider {
             usage: {
               input_tokens: rawChunk.usage.prompt_tokens ?? 0,
               output_tokens: rawChunk.usage.completion_tokens ?? 0,
+              prompt_cache_hit_tokens: rawChunk.usage.prompt_cache_hit_tokens,
+              prompt_cache_miss_tokens: rawChunk.usage.prompt_cache_miss_tokens,
             },
           }
           pendingComplete = null
@@ -203,7 +252,7 @@ export class OpenAIProvider implements LLMProvider {
               let input: Record<string, unknown>
               const rawArgs = currentToolCall.arguments || ''
               try {
-                input = JSON.parse(rawArgs || '{}')
+                input = tryParseJSON(rawArgs || '{}') || {}
               } catch {
                 console.error(
                   '[openai] Failed to parse tool_call arguments (flush on new tool):',
@@ -237,12 +286,13 @@ export class OpenAIProvider implements LLMProvider {
         if (currentToolCall) {
           const finalArgs = currentToolCall.arguments || ''
           try {
+            const parsed = tryParseJSON(finalArgs || '{}')
             yield {
               type: 'tool_use',
               tool_call: {
                 id: currentToolCall.id,
                 name: currentToolCall.name,
-                input: JSON.parse(finalArgs || '{}'),
+                input: parsed || {},
               },
               reasoning_content: reasoningContent,
             }
@@ -274,6 +324,8 @@ export class OpenAIProvider implements LLMProvider {
             usage: {
               input_tokens: lastUsage.prompt_tokens ?? 0,
               output_tokens: lastUsage.completion_tokens ?? 0,
+              prompt_cache_hit_tokens: lastUsage.prompt_cache_hit_tokens,
+              prompt_cache_miss_tokens: lastUsage.prompt_cache_miss_tokens,
             },
           }
           reasoningContent = undefined
@@ -294,6 +346,8 @@ export class OpenAIProvider implements LLMProvider {
         ? {
             input_tokens: lastUsage.prompt_tokens ?? 0,
             output_tokens: lastUsage.completion_tokens ?? 0,
+            prompt_cache_hit_tokens: lastUsage.prompt_cache_hit_tokens,
+            prompt_cache_miss_tokens: lastUsage.prompt_cache_miss_tokens,
           }
         : undefined
       yield {
@@ -310,12 +364,14 @@ export class OpenAIProvider implements LLMProvider {
         ? {
             input_tokens: lastUsage.prompt_tokens ?? 0,
             output_tokens: lastUsage.completion_tokens ?? 0,
+            prompt_cache_hit_tokens: lastUsage.prompt_cache_hit_tokens,
+            prompt_cache_miss_tokens: lastUsage.prompt_cache_miss_tokens,
           }
         : undefined
       let input: Record<string, unknown>
       const rawFinalArgs = currentToolCall.arguments || ''
       try {
-        input = JSON.parse(rawFinalArgs || '{}')
+        input = tryParseJSON(rawFinalArgs || '{}') || {}
       } catch {
         console.error('[openai] Failed to parse tool_call arguments (final flush):', rawFinalArgs)
         input = {}

package/src/agent/session.ts

@@ -25,6 +25,8 @@ interface SessionData {
   totalInputTokens: number
   totalOutputTokens: number
   totalApiCalls: number
+  totalCacheHitTokens?: number
+  totalCacheMissTokens?: number
   mode: 'code' | 'plan' | 'ask'
   model: string
   provider: string
@@ -222,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)
 }
 
@@ -259,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
 
@@ -316,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,
@@ -358,6 +389,8 @@ export class Session {
     session.totalInputTokens = data.totalInputTokens
     session.totalOutputTokens = data.totalOutputTokens
     session.totalApiCalls = data.totalApiCalls
+    session.totalCacheHitTokens = data.totalCacheHitTokens ?? 0
+    session.totalCacheMissTokens = data.totalCacheMissTokens ?? 0
     return session
   }
 
@@ -410,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
@@ -583,6 +618,15 @@ export class Session {
               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) {
@@ -600,6 +644,10 @@ export class Session {
                   this.turnApiCalls,
                   this.totalApiCalls,
                   out,
+                  this.turnCacheHitTokens,
+                  this.turnCacheMissTokens,
+                  this.totalCacheHitTokens,
+                  this.totalCacheMissTokens,
                 )
                 writeOut('\n\n', out)
                 saveTokenUsage(
@@ -687,6 +735,10 @@ export class Session {
             this.turnApiCalls,
             this.totalApiCalls,
             out,
+            this.turnCacheHitTokens,
+            this.turnCacheMissTokens,
+            this.totalCacheHitTokens,
+            this.totalCacheMissTokens,
           )
           writeOut('\n\n', out)
         }
@@ -712,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)
@@ -802,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)
     }