thincoder 0.12.21 → 0.12.23

package/README.md

@@ -15,7 +15,7 @@ Design philosophy (the entire meaning of the name): if the Node standard library
 - **Fix-verify loop**: file changes without `verify` get pushed back — syntax check + tests must pass before the agent can claim completion (auto-repair up to 3 rounds)
 - **Checkpoint system**: auto-snapshot before every user task, `list`/`create`/`rewind` tools for the model, single-file restore — rewinding itself is reversible (pre-rewind state auto-saved)
 - **Codebase understanding** ⭐0.5.0: `repo_outline` (dependency outline, auto-injected at startup), `code_search` (source FTS5 + vectors + JSDoc extraction), `doc_search` (docs chunked by ## headings) — background indexing, auto-incremental updates on file writes, three tools guided by "structure → intent → details"
-- **Model adaptation** ⭐: top-tier only, latest only. Built-in flagship models from twelve providers — DeepSeek / Kimi / GLM / Qwen / MiniMax / OpenAI / Claude / Gemini / Grok / Mistral / Volcengine Ark (豆包) / Hunyuan (腾讯混元) / SiliconFlow (硅基流动) / OpenRouter / Groq. No legacy model compatibility, no local model support. Auto-matched context windows, truncation-resume protocols (prefix/partial), thinking-mode APIs (thinking.type / reasoning_effort), reasoning_content echo strategies (reasoningEcho), output limits, temperature range clamping — all deeply adapted.
+- **Model adaptation** ⭐: top-tier only, latest only. Built-in flagship models from seventeen providers — DeepSeek / Kimi / Kimi For Coding / GLM / Qwen / Qwen Token Plan / MiniMax / OpenAI / Claude / Gemini / Grok / Mistral / Volcengine Ark (豆包) / Hunyuan (腾讯混元) / SiliconFlow (硅基流动) / OpenRouter / Groq. No legacy model compatibility, no local model support. Auto-matched context windows, truncation-resume protocols (prefix/partial), thinking-mode APIs (thinking.type / reasoning_effort), reasoning_content echo strategies (reasoningEcho), output limits, temperature range clamping — all deeply adapted.
 - **Toolset**: `read` / `write` / `edit` / `bash` / `glob` (supports `**`) / `grep` / `websearch` / `ls` / `fetch` + `read_image` (image/video paste) + three retrieval tools + MCP — all zero-dependency, file tools confined to the working directory
 - **Memory system**: three layers (personal/project/team), FTS5 + vector RRF hybrid retrieval, git-friendly markdown format
 - **Two-phase tool scheduling**: permission prompts serialized, read-only tools parallelized, side-effect tools serialized
@@ -152,6 +152,12 @@ Environment variables: `THINCODER_API_KEY` (or `DEEPSEEK_API_KEY` / `OPENAI_API_
       },
     ],
   },
+  "websearch": {
+    // optional: Tavily structured search (stable JSON API, no HTML scraping).
+    // Empty apiKey → silently falls back to Bing HTML extraction (zero-config).
+    "provider": "tavily",
+    "apiKey": "tvly-...", // https://tavily.com — has a free monthly tier
+  },
 }
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thincoder",
-  "version": "0.12.21",
+  "version": "0.12.23",
   "description": "Thin coding agent - zero dependencies, no build step, Node.js native. Sharp code, zero bloat.",
   "keywords": [
     "ai",

package/src/config.mjs

@@ -66,6 +66,10 @@ const DEFAULTS = {
   mcp: {
     servers: [],
   },
+  websearch: {
+    provider: "tavily",  // structured search API; empty apiKey → fall back to Bing HTML scraping
+    apiKey: "",          // Tavily key (tvly-...) — optional
+  },
 }
 
 /**

package/src/provider/core.mjs

@@ -40,6 +40,11 @@ export function createProvider(config) {
 
 /** Send a streaming chat completion request with automatic continuation on truncation */
 export async function chat(provider, { messages, tools, onToken, onReasoning, onWait, signal, streamRules, firedPatterns }) {
+  // Sanitize BEFORE format dispatch — image poisoning bricks anthropic/google sessions
+  // the same way it bricks OpenAI-format ones (all raster-only).
+  const spec = specForModel(provider.model)
+  messages = stripImagesForTextModel(messages, spec)
+
   // Format dispatch: delegate to non-OpenAI transports
   if (provider.format === "anthropic") {
     const { chat: anthropicChat } = await import("./anthropic.mjs")
@@ -62,8 +67,7 @@ export async function chat(provider, { messages, tools, onToken, onReasoning, on
     return result
   }
 
-  const spec = specForModel(provider.model)
-  messages = normalizeToolPairing(stripImagesForTextModel(messages, spec))
+  messages = normalizeToolPairing(messages)
   // Compile string-pattern rules to RegExp at call time
   const rules = compileStreamRules(streamRules)
   const body = {
@@ -181,23 +185,37 @@ export async function chat(provider, { messages, tools, onToken, onReasoning, on
 }
 
 /**
- * Replace image parts with text placeholders when the model has no vision support.
- * History may contain image_url parts (e.g. a session resumed after switching from a vision model
- * to a text-only one); text-only APIs like DeepSeek reject the ENTIRE request with 400 if any
- * message contains an image part, which bricks the conversation. Sanitize at send time — history
- * itself is left untouched, so switching back to a vision model restores the images.
+ * Replace image parts with text placeholders when they would 400 the request:
+ * - the model has no vision support at all (history may carry image_url parts from a
+ *   session resumed after switching from a vision model — text-only APIs like DeepSeek
+ *   reject the ENTIRE request, bricking the conversation);
+ * - the model IS vision-capable but the data URL is not a raster format it can ingest
+ *   (Kimi/Anthropic/OpenAI/Gemini are all raster-only — Kimi 400s "unsupported image
+ *   format" on EVERY subsequent request once an svg/bmp part sits in history).
+ * Sanitize at send time — history itself is left untouched, so switching back to a
+ * capable model/format restores the images. Non-data-URL image refs (http) pass through.
  */
+const RASTER_IMAGE_URL = /^data:image\/(png|jpe?g|gif|webp);base64,/
+
 export function stripImagesForTextModel(messages, spec) {
-  if (spec.multimodal) return messages
   let changed = false
   const out = messages.map((m) => {
     if (!Array.isArray(m.content) || !m.content.some((p) => p?.type === "image_url")) return m
+    let msgChanged = false
+    const parts = m.content.map((p) => {
+      if (p?.type !== "image_url") return p
+      const url = p.image_url?.url || ""
+      if (!url.startsWith("data:")) return p
+      if (spec.multimodal && RASTER_IMAGE_URL.test(url)) return p
+      msgChanged = true
+      const reason = spec.multimodal
+        ? `unsupported format ${url.match(/^data:([^;,]+)/)?.[1] || "unknown"}`
+        : "this model does not support image input"
+      return { type: "text", text: `[image omitted — ${reason}]` }
+    })
+    if (!msgChanged) return m
     changed = true
-    return {
-      ...m,
-      content: m.content.map((p) =>
-        p?.type === "image_url" ? { type: "text", text: "[image omitted — this model does not support image input]" } : p),
-    }
+    return { ...m, content: parts }
   })
   return changed ? out : messages
 }

package/src/provider/sse.mjs

@@ -2,6 +2,24 @@
  * provider/sse.mjs — SSE stream reader
  * Extracted from core.mjs. Parses Server-Sent Events for LLM chat responses.
  */
+
+/**
+ * Normalize provider cache fields into DeepSeek-style prompt_cache_hit/miss_tokens.
+ * DeepSeek already returns these; OpenAI/Kimi report the cache hit as
+ * prompt_tokens_details.cached_tokens; a few providers put cached_tokens at the
+ * usage top level. Miss is derived as prompt_tokens - hit when not reported.
+ */
+export function normalizeUsageCache(u) {
+  if (!u || u.prompt_cache_hit_tokens !== undefined) return u
+  const cached = u.prompt_tokens_details?.cached_tokens ?? u.cached_tokens
+  if (cached === undefined) return u
+  u.prompt_cache_hit_tokens = cached
+  if (u.prompt_cache_miss_tokens === undefined && typeof u.prompt_tokens === "number") {
+    u.prompt_cache_miss_tokens = Math.max(0, u.prompt_tokens - cached)
+  }
+  return u
+}
+
 export async function readSSE(response, { onToken, onReasoning, rules, signal, firedPatterns: sharedFired }) {
   // Early intercept: non-SSE responses — either error bodies (HTTP >= 400) or
   // valid single-chunk JSON completions (some APIs return JSON despite stream:true).
@@ -28,7 +46,7 @@ export async function readSSE(response, { onToken, onReasoning, rules, signal, f
       const parsed = JSON.parse(body)
       const choice = parsed.choices?.[0]
       if (choice) {
-        const result = { content: "", reasoning: "", toolCalls: [], usage: parsed.usage ?? null, finishReason: null }
+        const result = { content: "", reasoning: "", toolCalls: [], usage: normalizeUsageCache(parsed.usage ?? null), finishReason: null }
         const delta = choice.delta ?? {}
         result.content = delta.content ?? ""
         result.reasoning = delta.reasoning_content ?? ""
@@ -63,7 +81,7 @@ export async function readSSE(response, { onToken, onReasoning, rules, signal, f
       let json
       try { json = JSON.parse(data) } catch { continue }
 
-      if (json.usage) result.usage = json.usage
+      if (json.usage) result.usage = normalizeUsageCache(json.usage)
       const choice = json.choices?.[0]
       if (!choice) continue
       hasChoices = true

package/src/tools/file.mjs

@@ -75,7 +75,10 @@ export 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" }
+// Raster formats only — every mainstream vision API (Kimi, Anthropic, OpenAI, Gemini)
+// rejects svg/bmp. svg is served as text source below; bmp is refused with a hint.
+const IMAGE_EXTENSIONS = { png: "image/png", jpg: "image/jpeg", jpeg: "image/jpeg", gif: "image/gif", webp: "image/webp" }
+const MAX_SVG_CHARS = 100_000
 
 export const readImageTool = {
   name: "read_image",
@@ -83,7 +86,7 @@ export const readImageTool = {
   parameters: {
     type: "object",
     properties: {
-      path: { type: "string", description: "Path to image file (relative to cwd or absolute). Supports png, jpg, gif, webp, bmp, svg." },
+      path: { type: "string", description: "Path to image file (relative to cwd or absolute). Supports png, jpg, gif, webp. svg files are returned as text source (no vision API accepts svg)." },
     },
     required: ["path"],
   },
@@ -91,6 +94,19 @@ export const readImageTool = {
   multimodal: true, // returns JSON { text, images } — agent loop converts to multimodal user message
   /** Returns JSON: { text, images }, for the agent layer to convert into multimodal user messages */
   async execute(args, ctx) {
+    const abs = resolveInCwd(ctx, args.path)
+    const ext = abs.slice(abs.lastIndexOf(".") + 1).toLowerCase()
+
+    // SVG is text markup — return the source directly. Works with text-only models too
+    // (no vision gate), and never poisons history with an image part the API will 400 on.
+    if (ext === "svg") {
+      const st = await stat(abs).catch(() => null)
+      if (st && st.size > MAX_IMAGE_BYTES) throw new Error(`Image too large: ${Math.round(st.size / 1_000_000)}MB (max 15MB)`)
+      const src = normalizeEOL(await readFile(abs, "utf8"))
+      return `[read_image: ${args.path} (svg source, ${src.length} chars — no vision API accepts image/svg+xml, showing markup instead)]\n` +
+        truncate(src, MAX_SVG_CHARS)
+    }
+
     // Vision capability gate: injecting an image into a text-only model's history poisons the whole
     // conversation (every subsequent request 400s on the image part). Refuse before reading the file.
     const model = ctx.agent?.provider?.model
@@ -100,10 +116,11 @@ export const readImageTool = {
         `Verify visual output programmatically (file size, dimensions, pixel checks via code) or ask the user to switch to a vision-capable provider.`
       )
     }
-    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(", ")}`)
+    if (!mime) {
+      const hint = ext === "bmp" ? " Convert it to PNG first (no mainstream vision API accepts BMP)." : ""
+      throw new Error(`Unsupported image format: .${ext}. Supported: ${Object.keys(IMAGE_EXTENSIONS).join(", ")}, svg (as text source).${hint}`)
+    }
     // Check size before reading — prevent huge images from blowing up memory (20MB base64 ≈ 15MB raw)
     const imgStat = await stat(abs).catch(() => null)
     if (imgStat && imgStat.size > MAX_IMAGE_BYTES) throw new Error(`Image too large: ${Math.round(imgStat.size / 1_000_000)}MB (max 15MB)`)

package/src/tools/read_image.md

@@ -1,7 +1,8 @@
-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.
+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. The image is base64-encoded and included in the response. Large images (>20MB) are rejected.
 
 Parameters:
-- path (required): Path to image file (relative to cwd or absolute). Supports png, jpg, gif, webp, bmp, svg.
+- path (required): Path to image file (relative to cwd or absolute). Supports png, jpg, gif, webp; svg is returned as text source.
 
 Notes:
-- 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.
+- Raster formats only (png/jpg/gif/webp): no mainstream vision API (Kimi, Anthropic, OpenAI, Gemini) accepts svg or bmp, and an unsupported image part in history makes every subsequent request fail with 400. svg files are returned as text source instead (readable by any model); bmp is rejected — convert to PNG first.
+- 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 — except svg, which needs no vision support since it is read as text.

package/src/tools/web.mjs

@@ -40,6 +40,30 @@ function bingUrl(query, page) {
 const ENGINES = [{ name: "bing", label: "Bing", url: bingUrl, extract: extractBing, ua: UA }]
 const ENGINE_NAMES = ENGINES.map(e => e.name)
 
+/** Structured search via Tavily (optional — config.websearch.apiKey). Returns
+ *  { engine, results } or null to fall back to Bing HTML scraping. */
+async function fetchTavily(query, limit, ctx) {
+  const apiKey = ctx?.agent?.config?.websearch?.apiKey
+  if (!apiKey) return null
+  const ctrl = new AbortController()
+  const timer = setTimeout(() => ctrl.abort(), FETCH_TIMEOUT)
+  try {
+    const response = await proxyFetch("https://api.tavily.com/search", {
+      method: "POST",
+      headers: { "Content-Type": "application/json", "Authorization": `Bearer ${apiKey}` },
+      body: JSON.stringify({ query, search_depth: "basic", max_results: limit, include_answer: false, include_raw_content: false }),
+      signal: ctrl.signal,
+    }, resolveWebProxy(ctx))
+    if (!response.ok) return null
+    const data = await response.json()
+    const results = (Array.isArray(data.results) ? data.results : []).map((r) => ({
+      href: r.url, title: r.title ?? "", snippet: r.content ?? "", _engine: "tavily",
+    }))
+    return { engine: "tavily", results }
+  } catch { return null }
+  finally { clearTimeout(timer) }
+}
+
 async function fetchEngine(engine, query, page, ctx) {
   const ctrl = new AbortController()
   const timer = setTimeout(() => ctrl.abort(), FETCH_TIMEOUT)
@@ -73,6 +97,12 @@ export const websearchTool = {
   async execute(args, ctx) {
     const limit = Math.min(args.limit ?? 8, 20)
     const page = Math.max(1, args.page ?? 1)
+    // Structured search first when a Tavily key is configured — stable, dated,
+    // no HTML scraping. Falls back to Bing silently.
+    const tavily = await fetchTavily(args.query, limit, ctx)
+    if (tavily && tavily.results.length > 0) {
+      return truncate(tavily.results.slice(0, limit).map((r, i) => `${i + 1}. [tavily] ${r.title}\n   ${r.href}\n   ${r.snippet}`).join("\n\n"))
+    }
     if (args.engine) {
       const engine = ENGINES.find(e => e.name === args.engine)
       if (!engine) return `Unknown engine '${args.engine}'. Available: ${ENGINE_NAMES.join(", ")}`
@@ -115,6 +145,17 @@ function headerOf(res, name) {
   return h[name.toLowerCase()] ?? null
 }
 
+/** Validate a redirect target: resolve relative → absolute, http/https only, and
+ *  SSRF-checked. Returns { target } on success or { error } (never follows into a
+ *  private host — the redirect SSRF bypass). */
+export function resolveRedirectTarget(loc, baseUrl) {
+  let target
+  try { target = new URL(loc, baseUrl).toString() } catch { return { error: "invalid redirect location" } }
+  if (!/^https?:\/\//.test(target)) return { error: "redirect target must be http/https" }
+  if (isPrivateUrl(target)) return { error: "redirect target is internal/private/metadata" }
+  return { target }
+}
+
 export const fetchTool = {
   name: "fetch",
   description: DESC("fetch"),
@@ -130,7 +171,11 @@ export const fetchTool = {
         if ([301, 302, 307, 308].includes(response.status)) {
           const loc = headerOf(response, "location")
           if (loc) {
-            const r2 = await proxyFetch(loc, { headers: { "User-Agent": UA } }, proxyUri)
+            // SSRF-check the redirect target (resolve relative → absolute) before
+            // following — a 3xx must not bounce a public URL into a private host.
+            const r = resolveRedirectTarget(loc, args.url)
+            if (r.error) throw new Error(`fetch failed: ${r.error}`)
+            const r2 = await proxyFetch(r.target, { headers: { "User-Agent": UA } }, proxyUri)
             if (!r2.ok) throw new Error(`fetch failed: HTTP ${r2.status}`)
             const ct2 = headerOf(r2, "content-type") ?? ""
             const b2 = await r2.text()