thincoder 0.7.1 → 0.7.3

package/src/provider.mjs

@@ -10,11 +10,109 @@ import { specForModel } from "./config.mjs"
 export const RETRYABLE_STATUS = new Set([408, 409, 425, 429, 500, 502, 503, 504])
 const MAX_RETRIES = 3
 const MAX_CONTINUATIONS = 3 // Partial Mode 截断续写上限（防异常的无限 length 循环）
+// 429 的专项退避：RPM/TPM 按 60s 窗口计（账户级独立计数器），通用退避的 1s/2s/4s 等不出窗口
+const RATE_LIMIT_BACKOFF_MS = [15_000, 30_000, 60_000]
 
 /**
- * 创建 provider。config: { baseURL, apiKey, model, maxTokens?, temperature?, thinking?, reasoningEffort? }
+ * 测试钩子：睡眠/时钟/窗口长度可替换（离线测试不能真等 60s）。
+ * 生产代码不要直接调 setTimeout/sleep，统一走这里。
+ */
+export const _rateHooks = {
+  sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+  now: () => Date.now(),
+  windowMs: 60_000,
+}
+
+// ---------------------------------------------------------------- TPM/RPM 主动节流闸门
+
+/**
+ * 滑动窗口闸门：发请求前若 窗口内已耗 + 本次估算 超预算，就睡到最早的记录滑出窗口。
+ * 按 baseURL+apiKey 记账（限速是账户级）；预算来自 provider.tpm / provider.rpm，
+ * 不配则闸门关闭（429 反应式退避仍然生效）。主循环/压缩摘要/子 agent/截断续写全走这里。
+ */
+const rateWindows = new Map() // key → { tokens: [{ts, n}], requests: [ts] }
+
+function rateKey(provider) {
+  return `${provider.baseURL}|${provider.apiKey ?? ""}`
+}
+
+/** 粗估文本 token 数（与 context.mjs 同口径：ASCII/4 + 非 ASCII/1；context 依赖本模块，不能反向 import） */
+function estimateText(s) {
+  let nonAscii = 0
+  for (let i = 0; i < s.length; i++) if (s.charCodeAt(i) > 0x7f) nonAscii++
+  return Math.ceil((s.length - nonAscii) / 4) + nonAscii
+}
+
+/** 本次请求的 prompt 估算：messages 正文 + 思考链 + tool_calls 参数 + tools schema */
+function estimateRequestTokens(body) {
+  let tokens = 0
+  for (const m of body.messages ?? []) {
+    if (typeof m.content === "string") tokens += estimateText(m.content)
+    if (typeof m.reasoning_content === "string") tokens += estimateText(m.reasoning_content)
+    for (const tc of m.tool_calls ?? []) {
+      tokens += estimateText(tc.function?.name ?? "") + estimateText(tc.function?.arguments ?? "")
+    }
+  }
+  if (body.tools) tokens += estimateText(JSON.stringify(body.tools))
+  return tokens
+}
+
+/** 闸门：超预算则睡到窗口腾出空间；onWait({phase:"gate", seconds}) 供 UI 展示等待 */
+async function rateGate(provider, estimated, onWait, signal) {
+  // 单次请求估算已超过 TPM 预算时闸门无意义（等到天荒地老也塞不下），放行由服务端裁决
+  const tpm = provider.tpm != null && estimated <= provider.tpm ? provider.tpm : null
+  const rpm = provider.rpm ?? null
+  if (tpm == null && rpm == null) return
+  const w = rateWindows.get(rateKey(provider)) ?? { tokens: [], requests: [] }
+  rateWindows.set(rateKey(provider), w)
+  for (;;) {
+    const now = _rateHooks.now()
+    const cutoff = now - _rateHooks.windowMs
+    w.tokens = w.tokens.filter((e) => e.ts > cutoff)
+    w.requests = w.requests.filter((ts) => ts > cutoff)
+    const usedTokens = w.tokens.reduce((s, e) => s + e.n, 0)
+    const overTokens = tpm != null ? usedTokens + estimated - tpm : 0
+    const overRequests = rpm != null ? w.requests.length + 1 - rpm : 0
+    if (overTokens <= 0 && overRequests <= 0) break
+    let waitMs = _rateHooks.windowMs
+    if (overTokens > 0) {
+      // tokens 按时间升序：累加最早若干条，过期量足够腾出空间时的过期时刻
+      let freed = 0
+      for (const e of w.tokens) {
+        freed += e.n
+        if (freed >= overTokens) {
+          waitMs = Math.min(waitMs, e.ts + _rateHooks.windowMs - now)
+          break
+        }
+      }
+    }
+    if (overRequests > 0) {
+      // 等第 overRequests-1 条（升序）滑出，窗口内请求数即降回 rpm-1
+      waitMs = Math.min(waitMs, w.requests[overRequests - 1] + _rateHooks.windowMs - now)
+    }
+    waitMs = Math.max(waitMs, 50)
+    onWait?.({ phase: "gate", seconds: Math.ceil(waitMs / 1000) })
+    await _rateHooks.sleep(waitMs)
+    if (signal?.aborted) return
+  }
+}
+
+/** 记账：响应回来后按实测 usage 记（无 usage 用发送前的估算兜底）；被拒的请求不记（服务端未处理） */
+function recordRate(provider, estimated, usage) {
+  if (provider.tpm == null && provider.rpm == null) return
+  const w = rateWindows.get(rateKey(provider)) ?? { tokens: [], requests: [] }
+  rateWindows.set(rateKey(provider), w)
+  const now = _rateHooks.now()
+  w.requests.push(now)
+  // TPM 按输入+输出总量计（Moonshot 口径）
+  w.tokens.push({ ts: now, n: usage ? (usage.prompt_tokens ?? estimated) + (usage.completion_tokens ?? 0) : estimated })
+}
+
+/**
+ * 创建 provider。config: { baseURL, apiKey, model, maxTokens?, temperature?, thinking?, reasoningEffort?, tpm?, rpm? }
  * thinking: { type: "enabled"|"disabled" }  思维模式开关
  * reasoningEffort: "low"|"high"|"max"       推理强度（DeepSeek/Kimi/GLM 通用）
+ * tpm / rpm: 主动节流预算（tokens/分钟、请求数/分钟，按账户限速等级自配），不配则闸门关闭
  */
 export function createProvider(config) {
   if (!config?.baseURL) throw new Error("provider config: baseURL is required")
@@ -28,6 +126,8 @@ export function createProvider(config) {
     temperature: config.temperature,
     thinking: config.thinking,
     reasoningEffort: config.reasoningEffort,
+    tpm: config.tpm,
+    rpm: config.rpm,
   }
 }
 
@@ -35,6 +135,7 @@ export function createProvider(config) {
  * 流式对话。
  * messages: OpenAI 格式数组; tools: OpenAI tools schema（可选）
  * onToken(text): 正文流式回调; onReasoning(text): 思考流回调（DeepSeek-R1 类模型）
+ * onWait({phase, seconds}): 节流等待回调（phase: "gate"=主动节流 / "retry"=429 退避）
  * signal: AbortSignal（可选）
  * 返回 { content, reasoning, toolCalls: [{id, name, arguments}], usage, finishReason }
  * 注意：toolCalls[i].arguments 是 JSON 字符串，调用方负责 parse
@@ -46,7 +147,7 @@ export function createProvider(config) {
  * - prefixMode（DeepSeek）：assistant 消息带 prefix:true，且须走 /beta 端点；
  *   思考模式不支持前缀续写，已产出 reasoning 时放弃续写
  */
-export async function chat(provider, { messages, tools, onToken, onReasoning, signal }) {
+export async function chat(provider, { messages, tools, onToken, onReasoning, onWait, signal }) {
   const spec = specForModel(provider.model)
   const body = {
     model: provider.model,
@@ -77,8 +178,13 @@ export async function chat(provider, { messages, tools, onToken, onReasoning, si
   }
   if (tools?.length) body.tools = tools
 
-  const response = await requestWithRetry(provider, body, signal)
+  // TPM/RPM 主动节流：超预算先在本地睡到窗口腾出空间，不打 429 碰运气
+  const estimated = estimateRequestTokens(body)
+  await rateGate(provider, estimated, onWait, signal)
+
+  const response = await requestWithRetry(provider, body, signal, onWait)
   const result = await readSSE(response, { onToken, onReasoning })
+  recordRate(provider, estimated, result.usage)
 
   // 截断续写：仅规格表声明续写协议的模型（其他端点不认识 partial/prefix 字段，可能 400）
   if (!spec.partialMode && !spec.prefixMode) return result
@@ -101,6 +207,7 @@ export async function chat(provider, { messages, tools, onToken, onReasoning, si
       tools,
       onToken,
       onReasoning,
+      onWait,
       signal,
     })
     result.content += continued.content
@@ -145,11 +252,18 @@ export async function listModels(provider, { signal } = {}) {
   return (data.data ?? []).map((m) => m.id).filter(Boolean).sort()
 }
 
-/** 带重试的请求：网络错误与 429/5xx 指数退避（1s/2s/4s），其余 4xx 直接抛 */
-async function requestWithRetry(provider, body, signal) {
+/**
+ * 带重试的请求：网络错误与 5xx 指数退避（1s/2s/4s）；429 专项处理——
+ * 有 Retry-After 以它为准，没有按 15s/30s/60s 退避（RPM/TPM 是 60s 窗口，秒级退避等不出去）。
+ * 配额/余额错误（如 exceeded_current_quota_error）与限速同状态码但语义不同：重试无用，直接抛。
+ */
+async function requestWithRetry(provider, body, signal, onWait) {
   let lastError
+  let lastWas429 = false
+  let rateLimitHits = 0 // 连续 429 计数（退避档位用，与 attempt 解耦）
   for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
-    if (attempt > 0) await sleep(2 ** (attempt - 1) * 1000)
+    if (attempt > 0 && !lastWas429) await _rateHooks.sleep(2 ** (attempt - 1) * 1000)
+    lastWas429 = false
 
     let response
     try {
@@ -172,6 +286,21 @@ async function requestWithRetry(provider, body, signal) {
 
     const text = await response.text().catch(() => "")
     const message = `LLM API error ${response.status}: ${text}`
+    if (isQuotaError(text)) throw new Error(message)
+    if (response.status === 429) {
+      const retryAfter = Number(response.headers.get("retry-after"))
+      const waitMs =
+        Number.isFinite(retryAfter) && retryAfter > 0
+          ? retryAfter * 1000
+          : RATE_LIMIT_BACKOFF_MS[Math.min(rateLimitHits++, RATE_LIMIT_BACKOFF_MS.length - 1)]
+      lastError = new Error(message)
+      lastWas429 = true
+      if (attempt < MAX_RETRIES) {
+        onWait?.({ phase: "retry", seconds: Math.ceil(waitMs / 1000) })
+        await _rateHooks.sleep(waitMs)
+      }
+      continue
+    }
     if (RETRYABLE_STATUS.has(response.status)) {
       lastError = new Error(message)
       continue
@@ -181,6 +310,16 @@ async function requestWithRetry(provider, body, signal) {
   throw lastError
 }
 
+/** 配额/余额错误（重试无意义）：错误体 type 含 quota，如 Moonshot exceeded_current_quota_error */
+function isQuotaError(text) {
+  try {
+    const type = JSON.parse(text)?.error?.type
+    return typeof type === "string" && type.includes("quota")
+  } catch {
+    return false
+  }
+}
+
 /** 解析 SSE 流，累积正文/思考/tool_calls */
 async function readSSE(response, { onToken, onReasoning }) {
   const result = { content: "", reasoning: "", toolCalls: [], usage: null, finishReason: null }
@@ -237,10 +376,6 @@ async function readSSE(response, { onToken, onReasoning }) {
   return result
 }
 
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms))
-}
-
 /** DeepSeek Prefix Completion 只在 /beta 端点开放：.../v1 → .../beta */
 function betaBaseURL(baseURL) {
   return baseURL.replace(/\/v1$/, "/beta")

package/src/repomap.mjs

@@ -109,15 +109,15 @@ function normalizeExt(p) {
   return p.replace(/\.(m?js|jsx|tsx?)$/i, "")
 }
 
-/** 从 code_chunks 取已知文件列表（复用索引），按路径解析生成大纲文本 */
-export function buildOutline(db, cwd, focusPath) {
+/**
+ * 内部：扫描全量文件，构建正向依赖图 + 反向引用图。
+ * 返回 { deps, importers, fileCount } 供 buildOutline / buildSummary 共用。
+ */
+function _buildDepGraph(db, cwd) {
   const allFiles = db.prepare(`SELECT DISTINCT path FROM code_chunks ORDER BY path`).all().map((r) => r.path)
+  if (allFiles.length === 0) return null
 
-  if (allFiles.length === 0) return "(no indexed source files; run codeSync or /reindex first)"
-
-  // 构建正向（谁 import 谁）+ 反向（被谁 import）图——总是全量扫描，
-  // 因为聚焦一个文件也需要知道别的文件是否 import 了它
-  const deps = new Map()      // path → { imports: Set, exports: Set, size: number }
+  const deps = new Map()      // path → { imports: Set, exports: Set, size: number, dir: string }
   const importers = new Map() // importee → Set<importer>
 
   for (const rel of allFiles) {
@@ -140,7 +140,6 @@ export function buildOutline(db, cwd, focusPath) {
     // 把 import 路径解析成相对路径（处理 ./ ../）
     const resolved = []
     for (let imp of imports) {
-      // 去掉 ./ 前缀
       if (imp.startsWith("./")) imp = imp.slice(2)
       const dir = rel.includes("/") ? rel.slice(0, rel.lastIndexOf("/")) : ""
       const parts = imp.split("/")
@@ -154,7 +153,8 @@ export function buildOutline(db, cwd, focusPath) {
       }
     }
 
-    deps.set(rel, { imports: new Set(resolved), exports: new Set(exports), size: Math.floor(text.length / 1024) })
+    const dir = rel.includes("/") ? rel.slice(0, rel.lastIndexOf("/")) : "."
+    deps.set(rel, { imports: new Set(resolved), exports: new Set(exports), size: Math.floor(text.length / 1024), dir })
 
     for (const r of resolved) {
       if (!importers.has(r)) importers.set(r, new Set())
@@ -162,7 +162,97 @@ export function buildOutline(db, cwd, focusPath) {
     }
   }
 
-  // 生成文本
+  return { deps, importers, fileCount: allFiles.length }
+}
+
+/**
+ * 生成紧凑架构摘要（替换旧的全量注入）。
+ * 三层信息，每层信息密度递减：
+ *  1. 目录级依赖（多目录项目才有意义，单目录跳过）
+ *  2. 枢纽文件 Top-12（被 import 最多的文件——架构骨架）
+ *  3. 入口文件（无人 import 的文件——启动/顶层入口）
+ * 输出天然有界（~1000-2000 字符），不再需要 OUTLINE_INJECT_MAX 硬截断。
+ */
+export function buildSummary(db, cwd) {
+  const graph = _buildDepGraph(db, cwd)
+  if (!graph) return "(no indexed source files; run codeSync or /reindex first)"
+  const { deps, importers, fileCount } = graph
+
+  const out = []
+  out.push(`${fileCount} source files indexed.`)
+
+  // 1) 目录级依赖
+  const dirDeps = new Map() // dir → Set<imported-dir>
+  const dirSet = new Set()
+  for (const [rel, d] of deps) {
+    dirSet.add(d.dir)
+    if (!dirDeps.has(d.dir)) dirDeps.set(d.dir, new Set())
+    for (const imp of d.imports) {
+      const targetDir = imp.includes("/") ? imp.slice(0, imp.lastIndexOf("/")) : "."
+      if (targetDir !== d.dir) dirDeps.get(d.dir).add(targetDir)
+    }
+  }
+  if (dirSet.size > 1) {
+    out.push("Directory dependencies:")
+    for (const dir of [...dirSet].sort()) {
+      const targets = dirDeps.get(dir)
+      if (targets?.size) {
+        out.push(`  ${dir}/ → ${[...targets].sort().join(", ")}/`)
+      } else {
+        out.push(`  ${dir}/ (leaf)`)
+      }
+    }
+  }
+
+  // 2) 枢纽文件 Top-12：按被 import 次数降序
+  const HUB_LIMIT = 12
+  const hubScores = []
+  for (const [rel] of deps) {
+    const key = rel.replace(/\.(m?js|jsx|tsx?)$/i, "")
+    const rev = importers.get(key)
+    if (rev?.size) hubScores.push({ path: rel, count: rev.size })
+  }
+  hubScores.sort((a, b) => b.count - a.count)
+  if (hubScores.length > 0) {
+    out.push(`Hub files (by inbound dependencies, top ${Math.min(hubScores.length, HUB_LIMIT)}):`)
+    for (const h of hubScores.slice(0, HUB_LIMIT)) {
+      const d = deps.get(h.path)
+      const kb = d?.size ? ` (${d.size} KB)` : ""
+      const key = h.path.replace(/\.(m?js|jsx|tsx?)$/i, "")
+      const rev = importers.get(key)
+      const shortRefs = rev.size <= 5
+        ? [...rev].join(", ")
+        : [...rev].slice(0, 4).join(", ") + ` +${rev.size - 4} more`
+      out.push(`  ${h.path}${kb} — imported by: ${shortRefs}`)
+    }
+  }
+
+  // 3) 入口文件：无人 import 的（叶子/入口）
+  const entries = []
+  for (const [rel] of deps) {
+    const key = rel.replace(/\.(m?js|jsx|tsx?)$/i, "")
+    if (!importers.has(key) || importers.get(key).size === 0) {
+      entries.push(rel)
+    }
+  }
+  if (entries.length > 0 && entries.length < fileCount) {
+    const limit = 8
+    const shown = entries.slice(0, limit)
+    out.push(`Entry points (not imported by others):`)
+    for (const e of shown) out.push(`  ${e}`)
+    if (entries.length > limit) out.push(`  ... +${entries.length - limit} more`)
+  }
+
+  out.push("For detailed per-file relationships, call repo_outline with a file path.")
+  return out.join("\n")
+}
+
+/** 从 code_chunks 取已知文件列表（复用索引），按路径解析生成大纲文本 */
+export function buildOutline(db, cwd, focusPath) {
+  const graph = _buildDepGraph(db, cwd)
+  if (!graph) return "(no indexed source files; run codeSync or /reindex first)"
+  const { deps, importers } = graph
+
   const files = focusPath ? [focusPath] : [...deps.keys()]
   const out = []
   const sorted = files.sort()

package/src/session.mjs

@@ -63,7 +63,14 @@ export function archiveCurrent(cwd, { exclude } = {}) {
 
   const dst = slotPath(cwd, slot)
   // 复制（rename 会丢当前）；走原子写，防中途崩溃留下截断的 JSON 丢归档
-  writeSessionFile(dst, JSON.parse(readFileSync(src, "utf8")))
+  let data
+  try {
+    data = JSON.parse(readFileSync(src, "utf8"))
+  } catch {
+    // 会话文件损坏，放弃归档，下次保存会覆盖
+    return
+  }
+  writeSessionFile(dst, data)
   m.slots[slot] = Date.now()
   delete m.slots._currentName
   saveManifest(cwd, m)
@@ -91,10 +98,14 @@ export function switchToSlot(cwd, slot) {
   const src = slotPath(cwd, slot)
   const dst = sessionPath(cwd)
   if (!existsSync(src)) return null
-  // 先删当前文件（archiveCurrent 是复制不是移动，所以它还在）
-  try { unlinkSync(dst) } catch { /* 不存在就算了 */ }
-  copyFileSync(src, dst)
-  unlinkSync(src)
+  try {
+    try { unlinkSync(dst) } catch { /* 不存在就算了 */ }
+    copyFileSync(src, dst)
+    unlinkSync(src)
+  } catch {
+    // 文件操作失败（磁盘满/权限不足/锁文件），放弃切换
+    return null
+  }
 
   // 重读 manifest（archiveCurrent 改了它）
   const m2 = loadManifest(cwd)

package/src/tools/read_image.md

@@ -0,0 +1,3 @@
+Read an image file and return it as multimodal content visible to the model. Use this to view screenshots, UI mockups, diagrams, or any visual content. The model only sees images through this tool — it cannot "see" files directly. Supports png, jpg, gif, webp, bmp, svg. The image is base64-encoded and included in the response. Large images (>20MB) are rejected.
+
+Note: this tool only works with models that support vision/image input (Kimi K3, Qwen3.7, MiniMax M3). Pure text models (DeepSeek V4, GLM-5) will receive an error.

package/src/tools.mjs

@@ -117,6 +117,18 @@ function gitDiffOne(cwd, abs) {
   }
 }
 
+/** 文件变更后自动语法检查：仅对 .mjs/.js 文件，不抛错，结果追加到工具返回值 */
+function autoSyntaxCheck(abs) {
+  if (!/\.(m?js)$/i.test(abs)) return ""
+  try {
+    execFileSync("node", ["--check", abs], { stdio: ["ignore", "pipe", "pipe"], timeout: 10000 })
+    return "\nSyntax: OK"
+  } catch (e) {
+    const err = (e.stderr || e.stdout || e.message || "").toString().split("\n").slice(0, 3).join("\n")
+    return `\nSyntax: FAILED — ${err}`
+  }
+}
+
 /** 目标可能不存在（write 新文件），逐级向上找真实存在的祖先做 realpath */
 function realpathNearest(abs) {
   let cur = abs
@@ -223,6 +235,45 @@ const readTool = {
   },
 }
 
+// ---------------------------------------------------------------- read_image
+
+const IMAGE_EXTENSIONS = { png: "image/png", jpg: "image/jpeg", jpeg: "image/jpeg", gif: "image/gif", webp: "image/webp", bmp: "image/bmp", svg: "image/svg+xml" }
+
+const readImageTool = {
+  name: "read_image",
+  description: DESC("read_image"),
+  parameters: {
+    type: "object",
+    properties: {
+      path: { type: "string", description: "Path to image file (relative to cwd or absolute). Supports png, jpg, gif, webp, bmp, svg." },
+    },
+    required: ["path"],
+  },
+  readonly: true,
+  /** 返回 JSON：{ text, images }，供 agent 层转为多模态 user 消息 */
+  async execute(args, ctx) {
+    const abs = resolveInCwd(ctx, args.path)
+    const ext = abs.slice(abs.lastIndexOf(".") + 1).toLowerCase()
+    const mime = IMAGE_EXTENSIONS[ext]
+    if (!mime) throw new Error(`Unsupported image format: .${ext}. Supported: ${Object.keys(IMAGE_EXTENSIONS).join(", ")}`)
+    const buf = await readFile(abs) // raw buffer, no encoding
+    const b64 = buf.toString("base64")
+    // 图片太大（>20MB base64）拒绝，避免撑爆上下文
+    if (b64.length > 20_000_000) throw new Error(`Image too large: ${(b64.length / 1_000_000).toFixed(1)}MB base64 (max 20MB)`)
+    const bytes = buf.length
+    const result = JSON.stringify({
+      text: `[read_image: ${args.path} (${mime}, ${bytes} bytes)]`,
+      images: [{ type: "image_url", image_url: { url: `data:${mime};base64,${b64}` } }],
+    })
+    // 粘贴产生的临时文件用完即删，不留垃圾
+    const basename = abs.includes("/") ? abs.slice(abs.lastIndexOf("/") + 1) : abs.slice(abs.lastIndexOf("\\") + 1)
+    if (basename.startsWith(".thincoder-paste-")) {
+      try { await unlink(abs) } catch { /* 删不掉就算了 */ }
+    }
+    return result
+  },
+}
+
 // ---------------------------------------------------------------- write
 
 const writeTool = {
@@ -244,7 +295,7 @@ const writeTool = {
     if (st?.isDirectory()) throw new Error(`Path is a directory: ${abs}`)
     await writeFile(abs, args.content, "utf8")
     const diff = gitDiffOne(ctx.cwd, abs)
-    return `Wrote ${args.content.length} chars to ${abs}${diff ? "\n" + diff : ""}`
+    return `Wrote ${args.content.length} chars to ${abs}${diff ? "\n" + diff : ""}${autoSyntaxCheck(abs)}`
   },
 }
 
@@ -289,7 +340,7 @@ const editTool = {
       : content.replace(args.old_string, () => args.new_string)
     await writeFile(abs, updated, "utf8")
     const diff = gitDiffOne(ctx.cwd, abs)
-    return `Edited ${abs}: replaced ${args.replace_all ? occurrences : 1} occurrence(s)${diff ? "\n" + diff : ""}`
+    return `Edited ${abs}: replaced ${args.replace_all ? occurrences : 1} occurrence(s)${diff ? "\n" + diff : ""}${autoSyntaxCheck(abs)}`
   },
 }
 
@@ -340,7 +391,7 @@ const insertAfterTool = {
     const updated = lines.join("\n")
     await writeFile(abs, updated, "utf8")
     const diff = gitDiffOne(ctx.cwd, abs)
-    return `Inserted after line ${targetLine} in ${abs}${diff ? "\n" + diff : ""}`
+    return `Inserted after line ${targetLine} in ${abs}${diff ? "\n" + diff : ""}${autoSyntaxCheck(abs)}`
   },
 }
 
@@ -468,7 +519,11 @@ const applyPatchTool = {
       await writeFile(p.abs, p.content, "utf8")
     }
     const summary = planned.map((p) => `  ${p.isNew ? "created " : "modified"} ${p.path}`).join("\n")
-    return `Applied patch to ${planned.length} file(s):\n${summary}`
+    const syntaxResults = planned.map((p) => {
+      const r = autoSyntaxCheck(p.abs)
+      return r ? `${p.path}:${r.replace("Syntax: ", "")}` : ""
+    }).filter(Boolean).join("\n")
+    return `Applied patch to ${planned.length} file(s):\n${summary}${syntaxResults ? "\n\nSyntax checks:\n" + syntaxResults : ""}`
   },
 }
 
@@ -924,7 +979,7 @@ function htmlToText(html) {
     .trim()
 }
 
-export const builtinTools = [readTool, writeTool, editTool, insertAfterTool, applyPatchTool, syntaxCheckTool, bashTool, globTool, grepTool, websearchTool, lsTool, fetchTool]
+export const builtinTools = [readTool, writeTool, editTool, insertAfterTool, applyPatchTool, syntaxCheckTool, readImageTool, bashTool, globTool, grepTool, websearchTool, lsTool, fetchTool]
 
 // ---------------------------------------------------------------- delete