lonny-agent 0.2.3 → 0.2.6

package/src/agent/providers/ollama.ts

@@ -1,182 +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 {
-                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 {
-          // skip malformed JSON
-        }
-      }
-    }
-  }
-}
+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
@@ -201,9 +250,14 @@ export class OpenAIProvider implements LLMProvider {
           if (tc.id) {
             if (currentToolCall) {
               let input: Record<string, unknown>
+              const rawArgs = currentToolCall.arguments || ''
               try {
-                input = JSON.parse(currentToolCall.arguments || '{}')
+                input = tryParseJSON(rawArgs || '{}') || {}
               } catch {
+                console.error(
+                  '[openai] Failed to parse tool_call arguments (flush on new tool):',
+                  rawArgs,
+                )
                 input = {}
               }
               yield {
@@ -230,17 +284,23 @@ export class OpenAIProvider implements LLMProvider {
 
       if (chunk.choices?.[0]?.finish_reason) {
         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(currentToolCall.arguments || '{}'),
+                input: parsed || {},
               },
               reasoning_content: reasoningContent,
             }
           } catch {
+            console.error(
+              '[openai] Failed to parse tool_call arguments (finish_reason):',
+              finalArgs,
+            )
             yield {
               type: 'tool_use',
               tool_call: {
@@ -264,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
@@ -284,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 {
@@ -300,12 +364,16 @@ 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(currentToolCall.arguments || '{}')
+        input = tryParseJSON(rawFinalArgs || '{}') || {}
       } catch {
+        console.error('[openai] Failed to parse tool_call arguments (final flush):', rawFinalArgs)
         input = {}
       }
       yield {