lonny-agent 0.2.4 → 0.2.7

package/src/agent/compaction.ts

@@ -186,12 +186,19 @@ function buildSummary(messages: LLMMessage[]): string {
 
 function extractEditPaths(input: Record<string, unknown>): string[] {
   const paths: string[] = []
+  // Accumulate paths from legacy input format: { edits: [{ file_path: '...' }, ...] }
   if (Array.isArray(input.edits)) {
     for (const e of input.edits) {
       if (typeof e === 'object' && e && 'file_path' in e) {
-        paths.push(e.file_path as string)
+        paths.push((e as Record<string, unknown>).file_path as string)
       }
     }
   }
-  return paths
+  // Also support direct input format used by tests: { file_path: '...' }
+  const direct = input as Record<string, unknown>
+  if (typeof direct.file_path === 'string') {
+    paths.push(direct.file_path)
+  }
+  // Deduplicate to avoid reporting duplicates
+  return Array.from(new Set(paths))
 }

package/src/agent/index.ts

@@ -2,7 +2,11 @@ import * as readline from 'node:readline'
 import type { Config } from '../config/index.js'
 import { Session, type SessionOutput } from './session.js'
 
-export async function runAgent(prompt: string, config: Config): Promise<void> {
+export async function runAgent(
+  prompt: string,
+  config: Config,
+  preloadedSession?: Session,
+): Promise<void> {
   const output: SessionOutput = {
     write: text => process.stdout.write(text),
     confirmTool: async toolCalls => {
@@ -20,6 +24,7 @@ export async function runAgent(prompt: string, config: Config): Promise<void> {
       })
     },
   }
-  const session = (await Session.load(config, output)) || new Session(config, output)
+  const session =
+    preloadedSession ?? (await Session.load(config, output)) ?? new Session(config, output)
   await session.chat(prompt)
 }

package/src/agent/llm.ts

@@ -20,6 +20,10 @@ export interface LLMProvider {
 export interface TokenUsage {
   input_tokens: number
   output_tokens: number
+  /** DeepSeek-specific: tokens read from cache */
+  prompt_cache_hit_tokens?: number
+  /** DeepSeek-specific: tokens not in cache */
+  prompt_cache_miss_tokens?: number
 }
 
 export interface LLMChunk {

package/src/agent/memory.ts

@@ -0,0 +1,60 @@
+import * as fs from 'node:fs'
+import * as path from 'node:path'
+
+export interface MemoryEntry {
+  id: string
+  createdAt: string
+  content: string
+  tags?: string[]
+}
+
+const MEM_DIR = '.lonny/memory'
+
+export function getMemoryDir(cwd: string): string {
+  return path.resolve(cwd, MEM_DIR)
+}
+
+export function ensureMemoryDir(cwd: string): void {
+  const d = getMemoryDir(cwd)
+  if (!fs.existsSync(d)) fs.mkdirSync(d, { recursive: true })
+}
+
+export function loadMemory(cwd: string): MemoryEntry[] {
+  const d = getMemoryDir(cwd)
+  try {
+    if (!fs.existsSync(d)) return []
+    const files = fs.readdirSync(d).filter(f => f.endsWith('.json'))
+    const out: MemoryEntry[] = []
+    for (const f of files) {
+      try {
+        const data = JSON.parse(fs.readFileSync(path.join(d, f), 'utf-8'))
+        out.push(data as MemoryEntry)
+      } catch (e) {
+        // ignore corrupted file
+      }
+    }
+    // sort by createdAt
+    out.sort((a, b) => a.createdAt.localeCompare(b.createdAt))
+    return out
+  } catch (e) {
+    return []
+  }
+}
+
+export function saveMemory(cwd: string, entry: MemoryEntry): void {
+  ensureMemoryDir(cwd)
+  const id = entry.id || String(Date.now())
+  const file = path.join(getMemoryDir(cwd), `${id}.json`)
+  fs.writeFileSync(file, JSON.stringify(entry, null, 2), 'utf-8')
+}
+
+export function formatMemoryForPrompt(memories: MemoryEntry[]): string {
+  if (!memories || memories.length === 0) return ''
+  const parts: string[] = []
+  for (const m of memories) {
+    parts.push(
+      `- [${m.createdAt}] ${m.content.slice(0, 400).replace(/\n/g, ' ')}${m.content.length > 400 ? '…' : ''}`,
+    )
+  }
+  return parts.join('\n')
+}

package/src/agent/prompt-builder.ts

@@ -1,13 +1,26 @@
 import * as os from 'node:os'
 import type { Config } from '../config/index.js'
+import { formatToolTreeForPrompt } from '../tools/tree.js'
+import type { ToolDefinition } from '../tools/types.js'
+
+const CORE_TOOL_NAMES = new Set(['read', 'edit', 'bash', 'glob', 'grep'])
+
+import { formatMemoryForPrompt, loadMemory } from './memory.js'
 import { discoverProject, formatProjectContext } from './project.js'
 import { formatSkillsForPrompt, loadSkills } from './skills.js'
 
 /**
  * Build the system prompt for the current configuration.
  * Extracted from session.ts to keep module size manageable (<500 LoC target).
+ *
+ * @param config - Current configuration
+ * @param definitions - Optional tool definitions for dynamic tree generation.
+ *   When provided, replaces the hardcoded tool lists with a hierarchical tree.
  */
-export async function buildSystemPrompt(config: Config): Promise<string> {
+export async function buildSystemPrompt(
+  config: Config,
+  definitions?: ToolDefinition[],
+): Promise<string> {
   const platform = os.platform()
   const release = os.release()
   const shell = process.env.SHELL || process.env.ComSpec || 'unknown'
@@ -19,12 +32,33 @@ export async function buildSystemPrompt(config: Config): Promise<string> {
   const skills = loadSkills(cwd)
   const skillsSection = formatSkillsForPrompt(skills)
 
+  // ── Load long-term memory (persistent) ─────────────────────────────────
+  const memories = loadMemory(cwd)
+  const memorySection = formatMemoryForPrompt(memories)
+
   // ── Load project context ─────────────────────────────────────────────────
   const projectInfo = await discoverProject(cwd)
   const projectSection = formatProjectContext(projectInfo)
 
   // ── Mode-specific tool list ───────────────────────────────────────────
   function getToolListForMode(mode: string): string {
+    // When tool definitions are available, use the dynamic tree
+    if (definitions && definitions.length > 0) {
+      const header =
+        mode === 'plan'
+          ? 'Available tools (read-only investigation + write_plan):'
+          : mode === 'ask'
+            ? 'Available tools:'
+            : 'Available tools:'
+      const tree = formatToolTreeForPrompt(definitions, CORE_TOOL_NAMES)
+      const note =
+        mode !== 'ask'
+          ? '\n  Direct access: read, edit, bash, glob, grep\n  Extended tools: use `tool()` gateway (see tree above)\n'
+          : ''
+      return `${header}\n${tree}${note}\n`
+    }
+
+    // Fallback hardcoded lists (when definitions not available)
     if (mode === 'ask') {
       return `Available tools:
 - \`fetch\`: Fetch content from a URL
@@ -49,13 +83,13 @@ export async function buildSystemPrompt(config: Config): Promise<string> {
 - \`glob\`: Find files by glob pattern (pattern: string)
 - \`grep\`: Search file content by regex (pattern: string, include?: string, path?: string)
 - \`ls\`: List directory (path?: string)
-- \`bash\`: Execute a shell command
-- \`edit\`: Replace text in files — call with {edits: [{file_path: string, old_string: string, new_string: string}]} (array required)
-- \`install_skill\`: Install an npm package as a skill — fetches package info from npm, runs npm install, and creates a .lonny/skills/ file with usage instructions for the AI
-- \`find\`: Find files by name pattern (pattern: string, path?: string, maxResults?: number)
-- \`git\`: Run read-only git commands (command: string)
-- \`search\`: Search the web using Tavily (query: string, search_depth?: string, include_answer?: boolean, max_results?: number, topic?: string, days?: number)
-- \`exec\`: Run JavaScript in a sandbox to orchestrate multiple tool calls — all tools are available as \`await tools.xxx(args)\` inside exec (code mode only)
+      - \`bash\`: Execute a shell command — for running commands (NOT for creating or modifying files — use \`edit\` for that)
+      - \`edit\`: Replace text in files using markdown code block format. Use: \`edit({ content: "\`\`\`edit\\nfile: path\\nold: |\\ntext\\nnew: |\\ntext\\n\`\`\`" })\`. NOTE: There is no "write" tool — always use \`edit\` to modify files.
+  - \`install_skill\`: Install an npm package as a skill — fetches package info from npm, runs npm install, and creates a .lonny/skills/ file with usage instructions for the AI
+  - \`save_memory\`: Save a memory entry to long-term memory (content: string, tags?: string[])
+  - \`find\`: Find files by name pattern (pattern: string, path?: string, maxResults?: number)
+  - \`git\`: Run read-only git commands (command: string)
+  - \`search\`: Search the web using Tavily (query: string, search_depth?: string, include_answer?: boolean, max_results?: number, topic?: string, days?: number)
 `
   }
 
@@ -64,17 +98,51 @@ export async function buildSystemPrompt(config: Config): Promise<string> {
 RULES:
 1. Read first: Use read/grep/glob tools to gather all context you need before making any edits.
 2. Be thorough: Explore the relevant parts of the codebase.
-3. COST OPTIMIZATION (CRITICAL): Each API call costs money. You MUST maximize work per call. Use \`read(paths: [...])\` to read multiple files at once. Use \`edit({edits: [...]})\` to edit multiple files at once. Do NOT do sequential single-file reads or single-edit calls.
-4. When using \`edit\`, the \`edits\` value MUST be an array — even for a single change. Do NOT pass empty objects.
+ 3. AST tools (\`ast_query\`, \`ast_edit\`) are available via the \`tool()\` gateway. Use \`ast_query\` to inspect code structure (functions, classes, imports) before editing. Use \`ast_edit\` for structure-aware edits that preserve formatting.
+4. **For JavaScript/TypeScript files, prefer AST tools over raw text tools**: Use \`ast_query\` (not \`read\`) to understand file structure — it returns structured function/class/import/export data with exact line numbers. Use \`ast_edit\` (not \`edit\`) to replace entire functions, classes, or variables — it avoids string-matching issues and preserves formatting. Reserve \`edit\` for small surgical changes to function bodies or single-line fixes.
+5. COST OPTIMIZATION (CRITICAL): Each API call costs money. You MUST maximize work per call. Use \`read(paths: [...])\` to read multiple files at once. Use \`edit({ content: "..." })\` with multiple \`\`\`edit blocks to edit multiple files at once.
+6. There is NO "write" tool. To modify files, use the \`edit\` tool (listed above). Calling \`write\` will fail with "Unknown tool".
+
+${getToolListForMode(config.mode)}
+`
+  // ── Memory section (appended to system prompt to provide long-term context) ──
+  const memoryPromptSection = memorySection ? `\n## Long-term Memory\n\n${memorySection}` : ''
 
-${getToolListForMode(config.mode)}`
+  // NOTE: Mention save_memory in loop/code mode tool lists only if the tool exists at runtime.
+  // The tool may be provided via plugin or future implementation.
 
   // ── Mode-specific instructions ───────────────────────────────────────────
   const modeInstructions =
-    config.mode === 'plan'
-      ? `You are a planning agent. Your ONLY job is to investigate the codebase and produce an actionable implementation plan with a todo list.
+    config.mode === 'loop'
+      ? `You are an autonomous coding agent operating in LOOP mode. You will CONTINUE working on the task automatically after each turn — you do NOT need to ask for confirmation between steps.
 
-You CANNOT edit files. You do NOT have access to edit, bash (write mode), exec, or install_skill.
+${getToolListForMode('loop')}
+RULES (loop-specific):
+ 1. Read first: Use read/grep/glob tools to gather all context you need BEFORE making any edits. **For JS/TS files, prefer \`ast_query\` over \`read\`** — it returns structured function/class/import/export data with exact line numbers. Use \`tool({ name: "ast_query", params: { path: "file.ts", query: "structure" }})\` to inspect code structure via AST before editing. **For edits to whole functions/classes/variables in JS/TS, prefer \`ast_edit\` over \`edit\`** — use \`tool({ name: "ast_edit", params: { path: "file.ts", editType: "replace-node", targetLine: 5, newCode: "..." }})\` to avoid string-matching issues. Reserve \`edit\` for small surgical changes inside function bodies or single-line fixes. The \`read\` output prefixes each line with "<lineNumber>: " for easy reference. Do NOT include the "N: " prefix when copying text into \`edit\`.
+2. edit CALL FORMAT — use markdown code block format:
+   \`\`\`edit
+   file: src/file.ts
+   old: |
+     text to replace
+   new: |
+     replacement text
+   \`\`\`
+   Use separate \`\`\`edit blocks for multiple files.
+3. After making edits to a file, if you need to make ANOTHER edit to the SAME file, you MUST re-read it first to get the updated content.
+4. If \`edit\` reports \`old_string not found\`, do NOT retry with the same old_string — re-read the file immediately to see its actual current content, then retry with correctly-copied text.
+5. When copying old_string from \`read\` output, include 2-3 lines of context BEFORE and AFTER the target change to make the string unique in the file.
+ 6. On Windows, files may use CRLF (\\r\\n) line endings, but the \`edit\` tool normalizes them to LF (\\n). Always use \`\\n\` (not \`\\r\\n\`) in old_string/new_string.
+ 7. CRITICAL: old_string must be CONTIGUOUS — do NOT skip any lines between the old_string start and end. If you need to modify non-adjacent sections, use separate \`\`\`edit blocks.
+ 8. The \`|\` (pipe) after \`old:\` / \`new:\` supports chomping: \`|\` keeps trailing newline, \`|-\` strips it. Use \`|\` (not \`|-\`) when copying old_string — wrong chomping causes "old_string not found".
+ 9. COST OPTIMIZATION (CRITICAL): Each API call costs money. You MUST maximize work per call. Use \`read(paths: [...])\` to read multiple files at once. Use \`edit({ content: "..." })\` with multiple \`\`\`edit blocks to edit multiple files at once.
+10. TODO LIST MAINTENANCE: After completing a task item, update the corresponding plan file in \`.lonny/\` by checking off the TODO item (change \`- [ ]\` to \`- [x]\`). Use \`read\` to find the plan file, then \`edit\` to update the checkbox.
+11. LOOP BEHAVIOR: After this turn ends, you will AUTOMATICALLY receive a continuation prompt to continue working on the same task. You do NOT need to stop and wait for the user — keep going until the task is complete.
+12. If you believe the task is COMPLETE, end your response with a clear summary of what was accomplished. The system will detect this and stop the loop.
+13. You can use /stop at any time to halt execution.`
+      : config.mode === 'plan'
+        ? `You are a planning agent. Your ONLY job is to investigate the codebase and produce an actionable implementation plan with a todo list.
+
+You CANNOT edit files. You do NOT have access to edit, bash (write mode), or install_skill.
 Any attempt to call these tools will FAIL — they are simply unavailable in this mode.
 
 RULES (plan-specific):
@@ -86,6 +154,7 @@ RULES (plan-specific):
 6. If the plan is very long (or the todo list has many items), split into multiple files with descriptive names like \`backend-api.md\`, \`frontend-ui.md\`, \`database.md\`, etc.
 7. You MUST also include the todo list in your text response to the user (not just in the file).
 7. If the user asks you to modify files, run write commands, or install packages — refuse and explain they need to switch to code mode (\`/mode code\`).
+8. When the task involves writing code, your plan MUST follow Test-Driven Development: write tests first, then implement. Include a \`- [ ] Write tests for ...\` step BEFORE the implementation steps in the todo list.
 
 OUTPUT FORMAT (you MUST include both in write_plan AND in your response text):
 
@@ -101,35 +170,41 @@ A short, ordered description of the approach. Reference concrete files using \`p
 End your response by telling the user where the plan was saved and asking whether they want to switch to \`code\` mode to execute it. Use exactly: "Switch to code mode to implement this plan? (run \`/mode code\`)"
 
 If the user's request is a question rather than a change request, answer it directly and skip the plan/todo sections.`
-      : config.mode === 'ask'
-        ? `You are a Q&A assistant. You can ONLY use the following tools to search for information:
-- \`fetch\`: Fetch content from a URL
-- \`search\`: Search the web using Tavily
-
+        : config.mode === 'ask'
+          ? `You are a Q&A assistant. You can ONLY use the following tools to search for information:
+${getToolListForMode('ask')}
 You CANNOT execute any shell commands (\`bash\`), read local files, or make any changes to the codebase.
 
 RULES (ask-specific):
 1. Use \`fetch\` and \`search\` to find information and answer user questions.
 2. You CANNOT use \`bash\`, \`read\`, \`edit\`, \`write_plan\`, \`glob\`, \`grep\`, \`ls\`, \`find\`, or \`git\`.
 3. If the user wants you to modify code or run commands, explain you are in ask mode and suggest switching to code mode.`
-        : `You are a coding agent optimized for per-call pricing.
+          : `You are a coding agent optimized for per-call pricing.
 
 RULES (code-specific):
 1. Read first: Use read/grep/glob tools to gather all context you need BEFORE making any edits. The \`read\` output prefixes each line with "<lineNumber>: " for easy reference. Do NOT include the "N: " prefix when copying text into \`edit\`.
-2. edit CALL FORMAT — you MUST call edit with exactly this JSON shape:
-   { "edits": [{ "file_path": "src/file.ts", "old_string": "text to replace", "new_string": "replacement text" }] }
-   The "edits" value is ALWAYS an array, even for a single edit. Do NOT pass file_path/old_string/new_string as top-level keys. Do NOT pass an empty object {}.
+2. edit CALL FORMAT — use markdown code block format:
+   \`\`\`edit
+   file: src/file.ts
+   old: |
+     text to replace
+   new: |
+     replacement text
+   \`\`\`
+   Use separate \`\`\`edit blocks for multiple files.
 3. After making edits to a file, if you need to make ANOTHER edit to the SAME file, you MUST re-read it first to get the updated content.
 4. If \`edit\` reports \`old_string not found\`, do NOT retry with the same old_string — re-read the file immediately to see its actual current content, then retry with correctly-copied text.
-5. When copying old_string from \`read\` output, include 2-3 lines of context BEFORE and AFTER the target change to make the string unique in the file.
-6. On Windows, files may use CRLF (\\r\\n) line endings, but the \`edit\` tool normalizes them to LF (\\n). Always use \`\\n\` (not \`\\r\\n\`) in old_string/new_string.
-7. COST OPTIMIZATION (CRITICAL): Each API call costs money. You have a hard limit of ~5 API calls per task.
-8. TODO LIST MAINTENANCE: After completing a task item, update the corresponding plan file in \`.lonny/\` by checking off the TODO item (change \`- [ ]\` to \`- [x]\`). Use \`read\` to find the plan file, then \`edit\` to update the checkbox.`
+ 5. When copying old_string from \`read\` output, include 2-3 lines of context BEFORE and AFTER the target change to make the string unique in the file.
+ 6. CRITICAL: old_string must be CONTIGUOUS — do NOT skip any lines between the old_string start and end. If you need to modify non-adjacent sections, use separate \`\`\`edit blocks.
+ 7. The \`|\` (pipe) after \`old:\` / \`new:\` supports chomping: \`|\` keeps trailing newline, \`|-\` strips it. Use \`|\` (not \`|-\`) when copying old_string — wrong chomping causes "old_string not found".
+ 8. On Windows, files may use CRLF (\\r\\n) line endings, but the \`edit\` tool normalizes them to LF (\\n). Always use \`\\n\` (not \`\\r\\n\`) in old_string/new_string.
+ 9. COST OPTIMIZATION (CRITICAL): Each API call costs money. You have a hard limit of ~5 API calls per task.
+10. TODO LIST MAINTENANCE: After completing a task item, update the corresponding plan file in \`.lonny/\` by checking off the TODO item (change \`- [ ]\` to \`- [x]\`). Use \`read\` to find the plan file, then \`edit\` to update the checkbox.`
 
   // ── Built-in development methodologies ─────────────────────────────────
   // Embedded directly from Superpowers — no skill files needed.
   const methodologySection =
-    config.mode === 'code'
+    config.mode === 'code' || config.mode === 'loop'
       ? `
 
 ## Development Methodology
@@ -165,17 +240,20 @@ Before writing a plan, explore the user's request thoroughly:
 - Shell: ${shell}
 - Working directory: ${cwd}
 - OS: ${isWindows ? 'Windows' : 'Linux/macOS'}
-- Available shell commands: ${isWindows ? 'PowerShell (cmd is also available but PowerShell is preferred)' : 'bash'}
-${isWindows ? '  - Use PowerShell. Do NOT use Unix commands like `cat`, `ls`, `grep`, `which`, `chmod`, `mv`, `cp`, `rm`, `touch`, `mkdir`, `uname`, etc.' : ''}
-${isWindows ? '  - Use `type` instead of `cat`, `dir` instead of `ls`, `where` instead of `which`' : ''}`
+  - Available shell commands: ${isWindows ? 'PowerShell (cmd is also available but PowerShell is preferred)' : 'bash'}
+${isWindows ? '  ⚠️  THIS IS WINDOWS. Do NOT use Unix/Linux paths like `/workspace/...` or `/home/...`. The working directory is a Windows path (e.g. `C:\\Users\\...`).' : ''}
+${isWindows ? '  ⚠️  Do NOT use Unix commands: `find`, `cat`, `ls -la`, `which`, `cp`, `mv`, `rm`, `touch`, `chmod`, `mkdir`, `grep`, `head`, `tail`. They will ALL fail.' : ''}
+${isWindows ? '  - Use `type` instead of `cat`, `dir` instead of `ls`, `where` instead of `which`, `Select-Object -First N` instead of `head -N`' : ''}
+${isWindows ? '  - Use `;` (semicolon) instead of `&&` to chain commands' : ''}
+${isWindows ? '  - ⚠️  `Select-String` exits with code 1 when no match is found (e.g. `Select-String -Pattern "FAIL"` returns code 1 if no line contains FAIL). This is NORMAL — it does NOT mean the command failed. Append `; $LASTEXITCODE = 0` to suppress this.' : ''}`
 
   // Plan mode uses its own standalone tool list inside modeInstructions — skip sharedRules
   const rulesSection =
-    config.mode === 'plan'
+    config.mode === 'plan' || config.mode === 'loop'
       ? ''
       : `
 ${sharedRules}`
   return `${modeInstructions}
 
-${envSection}${rulesSection}${methodologySection}${projectSection}${skillsSection}`
+${envSection}${rulesSection}${methodologySection}${projectSection}${memoryPromptSection}${skillsSection}`
 }

package/src/agent/providers/google.ts

@@ -130,7 +130,6 @@ export class GoogleProvider implements LLMProvider {
     if (systemInstruction) {
       body.system_instruction = { parts: [{ text: systemInstruction }] }
     }
-
     // Make streaming API call
     const url = `${this.baseUrl}/models/${this.model}:streamGenerateContent?alt=sse`
     const response = await fetch(url, {

package/src/agent/providers/openai.ts

@@ -18,12 +18,46 @@ interface ExtendedCreateParams {
   stream_options?: { include_usage: boolean }
   thinking?: { type: string }
   reasoning_effort?: string
+  reasoning?: { effort: string }
   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
+  private baseURL?: string
   private thinking?: boolean
   private reasoningEffort?: string
   private enableCache: boolean
@@ -41,6 +75,7 @@ export class OpenAIProvider implements LLMProvider {
   ) {
     this.client = new OpenAI({ apiKey, baseURL })
     this.model = model || 'gpt-4o'
+    this.baseURL = baseURL
     this.thinking = thinking
     this.reasoningEffort = reasoningEffort
     this.enableCache = enableCache ?? false
@@ -119,6 +154,20 @@ export class OpenAIProvider implements LLMProvider {
       }
     })
 
+    // 检测当前对接的是否为官方 OpenAI 应用程序接口
+    const isOfficialOpenAI = this.baseURL ? /api\.openai\.com/i.test(this.baseURL) : true
+
+    // Build reasoning params compatible with the target API
+    const reasoningParams: Record<string, unknown> = {}
+    if (this.thinking) {
+      if (isOfficialOpenAI) {
+        reasoningParams.thinking = { type: 'enabled' }
+        reasoningParams.reasoning_effort = this.reasoningEffort || 'high'
+      } else {
+        reasoningParams.reasoning = { effort: this.reasoningEffort || 'high' }
+      }
+    }
+
     const stream: Stream<ChatCompletionChunk> = await (
       this.client.chat.completions.create as (
         params: ExtendedCreateParams,
@@ -131,9 +180,7 @@ export class OpenAIProvider implements LLMProvider {
         tools: openAIFormattedTools.length > 0 ? openAIFormattedTools : undefined,
         stream: true,
         stream_options: { include_usage: true },
-        ...(this.thinking
-          ? { thinking: { type: 'enabled' }, reasoning_effort: this.reasoningEffort || 'high' }
-          : {}),
+        ...reasoningParams,
         ...(this.enableCache ? { enable_cache: true } : {}),
       },
       signal ? { signal } : undefined,
@@ -146,7 +193,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 +213,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 +233,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 +267,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 +301,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 +339,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 +361,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 +379,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 = {}