thincoder 0.7.7 → 0.8.0

package/src/provider/core.mjs

@@ -0,0 +1,239 @@
+/**
+ * provider/core.mjs — LLM 调用核心
+ * chat / listModels / createProvider / requestWithRetry / readSSE
+ */
+
+import { specForModel } from "../config.mjs"
+import {
+  RETRYABLE_STATUS, MAX_RETRIES, MAX_CONTINUATIONS,
+  RATE_LIMIT_BACKOFF_MS, _rateHooks,
+  estimateRequestTokens, rateGate, recordRate,
+} from "./rate.mjs"
+
+export function createProvider(config) {
+  if (!config?.baseURL) throw new Error("provider config: baseURL is required")
+  if (!config?.apiKey) throw new Error("provider config: apiKey is required (config file or THINCODER_API_KEY env)")
+  if (!config?.model) throw new Error("provider config: model is required")
+  return {
+    baseURL: config.baseURL.replace(/\/+$/, ""),
+    apiKey: config.apiKey,
+    model: config.model,
+    maxTokens: config.maxTokens,
+    temperature: config.temperature,
+    thinking: config.thinking,
+    reasoningEffort: config.reasoningEffort,
+    tpm: config.tpm,
+    rpm: config.rpm,
+  }
+}
+
+export async function chat(provider, { messages, tools, onToken, onReasoning, onWait, signal }) {
+  const spec = specForModel(provider.model)
+  const body = {
+    model: provider.model,
+    messages,
+    stream: true,
+    stream_options: { include_usage: true },
+  }
+  if (provider.maxTokens) body.max_tokens = provider.maxTokens
+  if (provider.temperature != null) {
+    let t = provider.temperature
+    if (spec.tempRange) {
+      t = Math.min(spec.tempRange[1], Math.max(spec.tempRange[0], t))
+      t = Math.round(t * 100) / 100
+    }
+    body.temperature = t
+  }
+  if (provider.thinking) body.thinking = provider.thinking
+  if (provider.reasoningEffort) {
+    if (spec.reasoningEffortEnum && !spec.reasoningEffortEnum.includes(provider.reasoningEffort)) {
+      throw new Error(
+        `reasoning_effort "${provider.reasoningEffort}" not supported by model "${provider.model}"; ` +
+        `valid values: ${spec.reasoningEffortEnum.join(", ")}`
+      )
+    }
+    body.reasoning_effort = provider.reasoningEffort
+  }
+  if (tools?.length) body.tools = tools
+
+  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)
+
+  if (!spec.partialMode && !spec.prefixMode) return result
+  if (spec.prefixMode && !spec.partialMode && result.reasoning) return result
+  for (let n = 0; result.finishReason === "length" && result.content && n < MAX_CONTINUATIONS; n++) {
+    const continued = await chat(spec.prefixMode ? { ...provider, baseURL: betaBaseURL(provider.baseURL) } : provider, {
+      messages: [
+        ...messages,
+        spec.partialMode
+          ? {
+              role: "assistant",
+              content: result.content,
+              partial: true,
+              ...(result.reasoning ? { reasoning_content: result.reasoning } : {}),
+            }
+          : { role: "assistant", content: result.content, prefix: true },
+      ],
+      tools,
+      onToken,
+      onReasoning,
+      onWait,
+      signal,
+    })
+    result.content += continued.content
+    result.reasoning += continued.reasoning ?? ""
+    for (const tc of continued.toolCalls ?? []) {
+      const idx = tc.index ?? result.toolCalls.length
+      const s = (result.toolCalls[idx] ??= { id: "", name: "", arguments: "" })
+      if (tc.id) s.id = tc.id
+      s.name += tc.name ?? ""
+      s.arguments += tc.arguments ?? ""
+    }
+    result.finishReason = continued.finishReason
+    if (continued.usage) {
+      const sum = (k) => (result.usage?.[k] ?? 0) + (continued.usage[k] ?? 0)
+      result.usage = {
+        prompt_tokens: sum("prompt_tokens"),
+        completion_tokens: sum("completion_tokens"),
+        total_tokens: sum("total_tokens"),
+        prompt_cache_hit_tokens: sum("prompt_cache_hit_tokens"),
+        prompt_cache_miss_tokens: sum("prompt_cache_miss_tokens"),
+      }
+    }
+  }
+  return result
+}
+
+export async function listModels(provider, { signal } = {}) {
+  const response = await fetch(`${provider.baseURL}/models`, {
+    headers: { Authorization: `Bearer ${provider.apiKey}` },
+    signal,
+  })
+  if (!response.ok) {
+    const text = await response.text().catch(() => "")
+    throw new Error(`GET /models failed ${response.status}: ${text}`)
+  }
+  const data = await response.json()
+  return (data.data ?? []).map((m) => m.id).filter(Boolean).sort()
+}
+
+async function requestWithRetry(provider, body, signal, onWait) {
+  let lastError
+  let lastWas429 = false
+  let rateLimitHits = 0
+  for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+    if (attempt > 0 && !lastWas429) await _rateHooks.sleep(2 ** (attempt - 1) * 1000)
+    lastWas429 = false
+
+    let response
+    try {
+      response = await fetch(`${provider.baseURL}${provider.chatPath ?? "/chat/completions"}`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${provider.apiKey}`,
+        },
+        body: JSON.stringify(body),
+        signal: signal ? AbortSignal.any([signal, AbortSignal.timeout(120000)]) : AbortSignal.timeout(120000),
+      })
+    } catch (error) {
+      if (error.name === "AbortError") throw error
+      lastError = error
+      continue
+    }
+
+    if (response.ok) return response
+
+    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
+    }
+    throw new Error(message)
+  }
+  throw lastError
+}
+
+function isQuotaError(text) {
+  try {
+    const type = JSON.parse(text)?.error?.type
+    return typeof type === "string" && type.includes("quota")
+  } catch {
+    return false
+  }
+}
+
+async function readSSE(response, { onToken, onReasoning }) {
+  const result = { content: "", reasoning: "", toolCalls: [], usage: null, finishReason: null }
+  const decoder = new TextDecoder()
+  let buffer = ""
+
+  const processLines = (lines) => {
+    for (const line of lines) {
+      if (!line.startsWith("data:")) continue
+      const data = line.slice(5).trim()
+      if (!data || data === "[DONE]") continue
+
+      let json
+      try { json = JSON.parse(data) } catch { continue }
+
+      if (json.usage) result.usage = json.usage
+      const choice = json.choices?.[0]
+      if (!choice) continue
+      if (choice.finish_reason) result.finishReason = choice.finish_reason
+
+      const delta = choice.delta ?? {}
+      if (delta.reasoning_content) {
+        result.reasoning += delta.reasoning_content
+        onReasoning?.(delta.reasoning_content)
+      }
+      if (delta.content) {
+        result.content += delta.content
+        onToken?.(delta.content)
+      }
+      for (const tc of delta.tool_calls ?? []) {
+        const slot = (result.toolCalls[tc.index] ??= { id: "", name: "", arguments: "" })
+        if (tc.id) slot.id = tc.id
+        if (tc.function?.name && !slot.name) slot.name = tc.function.name
+        if (tc.function?.arguments) slot.arguments += tc.function.arguments
+      }
+    }
+  }
+
+  if (!response.body) throw new Error("No stream response body")
+  for await (const chunk of response.body) {
+    buffer += decoder.decode(chunk, { stream: true })
+    const lines = buffer.split("\n")
+    buffer = lines.pop()
+    processLines(lines)
+  }
+  buffer += decoder.decode()
+  processLines(buffer.split("\n"))
+  return result
+}
+
+function betaBaseURL(baseURL) {
+  // DeepSeek prefix 续写走 /beta 端点；只处理 /v1 后缀，缺 /v1 时追加 /beta
+  if (/\/v1$/.test(baseURL)) return baseURL.replace(/\/v1$/, "/beta")
+  return baseURL.endsWith("/") ? baseURL + "beta" : baseURL + "/beta"
+}

package/src/provider/index.mjs

@@ -0,0 +1,6 @@
+/**
+ * provider/index.mjs — 后端兼容重导出
+ * import { chat } from "./provider" → 自动解析到本文件
+ */
+export { chat, createProvider, listModels } from "./core.mjs"
+export { RETRYABLE_STATUS, _rateHooks, estimateText, estimateRequestTokens, rateGate, recordRate } from "./rate.mjs"

package/src/provider/rate.mjs

@@ -0,0 +1,104 @@
+/**
+ * provider/rate.mjs — TPM/RPM 主动节流闸门
+ * 滑动窗口记账，发请求前预检预算，超支则睡到窗口腾出空间。
+ */
+
+import { specForModel } from "../config.mjs"
+
+export const RETRYABLE_STATUS = new Set([408, 409, 425, 429, 500, 502, 503, 504])
+export const MAX_RETRIES = 3
+export const MAX_CONTINUATIONS = 3
+export const RATE_LIMIT_BACKOFF_MS = [15_000, 30_000, 60_000]
+
+/**
+ * 测试钩子：睡眠/时钟/窗口长度可替换（离线测试不能真等 60s）。
+ * 生产代码不要直接调 setTimeout/sleep，统一走这里。
+ */
+export const _rateHooks = {
+  sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+  now: () => Date.now(),
+  windowMs: 60_000,
+}
+
+const rateWindows = new Map() // key → { tokens: [{ts, n}], requests: [ts] }
+
+function rateKey(provider) {
+  // 归一化：/beta 和 /v1 视为同一账户的同一限流窗口（DeepSeek prefix continuation 改 /beta 端点）
+  const base = provider.baseURL.replace(/\/beta$/, "/v1")
+  return `${base}|${provider.apiKey ?? ""}`
+}
+
+/** 粗估文本 token 数。
+ *  ASCII 按 ~4 字符/token；非 ASCII（CJK/emoji）按 ~1 字符/token（保守，实测 BPE 1.5-2.5 字/token）。 */
+export 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 估算 */
+export 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
+}
+
+/** 闸门：超预算则睡到窗口腾出空间 */
+export async function rateGate(provider, estimated, onWait, signal) {
+  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) {
+      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) {
+      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) throw new DOMException("Aborted", "AbortError")
+  }
+}
+
+/** 记账：响应回来后按实测 usage 记 */
+export function recordRate(provider, estimated, usage) {
+  if (provider.tpm == null && provider.rpm == null) return
+  const key = rateKey(provider)
+  const w = rateWindows.get(key) ?? { tokens: [], requests: [] }
+  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)
+  w.requests.push(now)
+  w.tokens.push({ ts: now, n: usage ? (usage.prompt_tokens ?? estimated) + (usage.completion_tokens ?? 0) : estimated })
+  // 窗口已空则删条目，防长期跨 provider 配置时 Map 无界增长
+  if (w.tokens.length === 0 && w.requests.length === 0) rateWindows.delete(key)
+  else rateWindows.set(key, w)
+}

package/src/session.mjs

@@ -21,14 +21,20 @@ export function sessionPath(cwd) {
 function slotPath(cwd, n) { return sessionPath(cwd) + "." + n }
 function manifestPath(cwd) { return sessionPath(cwd) + ".manifest" }
 
-/** 原子写：先写临时文件再替换，防写入中途崩溃留下截断的 JSON 丢整个会话。
- *  不用 renameSync：Windows rename 目标已存在抛 EPERM */
+/** 原子写：先写临时文件再 rename 替换，防写入中途崩溃留下截断的 JSON 丢整个会话。
+ *  rename 在 POSIX 上原子；Windows 上目标已存在时 Node 24 用 MoveFileExW+REPLACE_EXISTING 也能原子替换。
+ *  某些旧 Windows 文件系统可能抛 EPERM，重试一次。 */
 function writeSessionFile(p, data) {
   mkdirSync(dirname(p), { recursive: true })
   const tmp = `${p}.tmp`
   writeFileSync(tmp, JSON.stringify(data), "utf8")
-  try { unlinkSync(p) } catch { /* 旧文件不存在就算了 */ }
-  renameSync(tmp, p)
+  try {
+    renameSync(tmp, p)
+  } catch {
+    // Windows EPERM 兜底：删目标后重试（极罕见，仅旧 NTFS/网络盘）
+    try { unlinkSync(p) } catch {}
+    renameSync(tmp, p)
+  }
 }
 
 // ========== 槽位管理 ==========
@@ -52,7 +58,8 @@ export function archiveCurrent(cwd, { exclude } = {}) {
   const m = loadManifest(cwd)
 
   let slot
-  const entries = Object.entries(m.slots)
+  // 只计数字 key 的槽位，排除 _currentName 等遗留非数字 key
+  const entries = Object.entries(m.slots).filter(([n]) => /^\d+$/.test(n))
   if (entries.length < MAX_SLOTS) {
     slot = 1
     while (m.slots[slot]) slot++
@@ -175,6 +182,12 @@ export function applySession(agent, data) {
   agent.goal = data.goal ?? null
   agent._pendingReminders = data.pendingReminders ?? []
   agent._sessionStart = data.sessionStart ?? null
+  // 重置轮次计数器：切换会话后不应继承旧会话的停滞/压缩状态
+  agent._turnsSinceTaskUpdate = 0
+  agent._turnsInPlanMode = 0
+  agent._compressFailures = 0
+  agent._verifyRetries = 0
+  agent._verifyPassed = false
   if (data.activeProvider && data.activeProvider !== agent.activeProvider) {
     const p = agent.providers?.find((pr) => pr.name === data.activeProvider)
     if (p) {

package/src/tools/bash.md

@@ -25,3 +25,4 @@ Notes:
 - Do NOT run destructive commands (rm -rf, force-push, drop table) without explicit user confirmation
 - After commands that change files (git checkout, npm install, etc.), repo_outline and code_search may be stale — re-run them to get current results.
 - Prefer read/glob/grep/ls for file operations inside the project — bash has no directory confinement.
+- NEVER use bash to write or modify files (echo/sed/printf > file, cat << EOF, etc.). Use write/edit/insert_after/apply_patch instead — they handle encoding, escaping, and directory confinement correctly.

package/src/tools/bash.mjs

@@ -0,0 +1,144 @@
+import {
+  DESC,
+  sanitizeOutput,
+  truncate,
+  makeDecoder,
+  BASH_TIMEOUT_MS,
+  hasFileRedirection,
+  shellSegments,
+  isDestructiveGitSegment,
+  isDestructiveCommand,
+  insideGitRepo,
+} from "./shared.mjs"
+import { spawn, execFileSync } from "node:child_process"
+
+/** 子进程环境变量白名单：只透传安全变量，隔离 API key 等敏感信息 */
+const SAFE_ENV_KEYS = new Set([
+  "PATH", "HOME", "USERPROFILE", "APPDATA", "LOCALAPPDATA",
+  "TEMP", "TMP", "TMPDIR", "LANG", "LC_ALL", "LC_CTYPE", "SHELL",
+  "ComSpec", "PATHEXT", "SystemRoot", "windir",
+  "NUMBER_OF_PROCESSORS", "PROCESSOR_ARCHITECTURE", "OS",
+  "PYTHONIOENCODING", "GIT_EDITOR", "EDITOR", "VISUAL",
+  "GIT_PAGER", "PAGER", "TERM",
+])
+
+export const bashTool = {
+  name: "bash",
+  description: DESC("bash"),
+  parameters: {
+    type: "object",
+    properties: {
+      command: { type: "string", description: "Shell command to execute" },
+      timeout: { type: "number", description: `Timeout in ms (default ${BASH_TIMEOUT_MS})` },
+    },
+    required: ["command"],
+  },
+  readonly: false,
+  async execute(args, ctx) {
+    // 安全预检：禁止 shell 重定向（> >> <）——应改用 write/edit/insert_after 工具
+    if (hasFileRedirection(args.command)) {
+      throw new Error("File redirection via bash is not allowed — use the write/edit/insert_after tools instead")
+    }
+    // 安全预检：破坏性非 git 命令（rm -rf / DROP TABLE 等）直接拒绝
+    if (shellSegments(args.command).some(isDestructiveCommand)) {
+      throw new Error("Destructive command blocked — use specific tools or confirm with the user first")
+    }
+    // 安全预检：销毁性 git 操作先检查未提交改动，有则拒绝——防一键清掉几小时工作
+    if (shellSegments(args.command).some(isDestructiveGitSegment)) {
+      if (!insideGitRepo(ctx.cwd)) {
+        throw new Error(`Refusing destructive git command: not a git repository: ${ctx.cwd}`)
+      }
+      const status = execFileSync("git", ["status", "--porcelain"], {
+        cwd: ctx.cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"],
+      }).trim()
+      if (status) {
+        throw new Error(
+          `Refusing destructive git command: uncommitted changes exist. Commit or stash first.\n` +
+          `(If uncommitted work was already lost, the checkpoint tool can restore the auto-snapshot: action=list, then action=rewind.)\n\n${status}`
+        )
+      }
+    }
+
+    return new Promise((resolve) => {
+      // detached: 让子进程成为进程组组长，超时/中断时才能整树杀掉（POSIX 用负 pid 组杀，
+      // Windows 用 taskkill /T）——只 kill 壳进程会把孙进程（如 npm test）留在后台继续跑
+      const killTree = () => {
+        if (process.platform === "win32") {
+          try { execFileSync("taskkill", ["/PID", String(child.pid), "/T", "/F"], { stdio: "ignore" }) } catch {}
+        } else {
+          try { process.kill(-child.pid, "SIGKILL") } catch {}
+          try { child.kill("SIGKILL") } catch {} // 组杀失败时兜底杀本体
+        }
+      }
+      // Windows 中文系统默认代码页是 GBK (CP936)，cmd.exe 重定向写文件时用 ANSI 代码页，
+      // chcp 65001 也改不了重定向的编码。bash 工具写含 CJK 的文件会产生 GBK——
+      // 提示词层已禁止用 bash 写文件（用 write/edit 工具替代），这里设 PYTHONIOENCODING
+      // 覆盖 Python 脚本的 stdout 编码（Python 是唯一可能正确响应环境变量的子进程）
+      const winCmd = process.platform === "win32"
+      const child = spawn(args.command, {
+        cwd: ctx.cwd,
+        shell: true,
+        windowsHide: true,
+        detached: process.platform !== "win32",
+        stdio: ["ignore", "pipe", "pipe"],
+        env: {
+          ...Object.fromEntries(
+            Object.entries(process.env).filter(([k]) => SAFE_ENV_KEYS.has(k))
+          ),
+          GIT_EDITOR: "true",
+          EDITOR: "true",
+          VISUAL: "true",
+          GIT_PAGER: "cat",
+          PAGER: "cat",
+          TERM: "dumb",
+          ...(winCmd ? { PYTHONIOENCODING: "utf-8" } : {}),
+        },
+      })
+      // stdout / stderr 各自独立解码（同进程通常同编码，但分开收集更干净，
+      // 且允许模型按 stderr 快速定位错误）
+      const outDecoder = makeDecoder()
+      const errDecoder = makeDecoder()
+      let outBuf = ""
+      let errBuf = ""
+      let truncatedNote = ""
+
+      const onStdout = (d) => {
+        const s = sanitizeOutput(outDecoder(d))
+        if (s) {
+          ctx.onOutput?.(s)
+          if (outBuf.length < 2_000_000) outBuf += s
+          else if (!truncatedNote) truncatedNote = "\n[... output exceeded 2MB, remainder discarded]"
+        }
+      }
+      const onStderr = (d) => {
+        const s = sanitizeOutput(errDecoder(d)) // 始终解码，防 pending 无限累积
+        if (errBuf.length < 2_000_000) errBuf += s
+      }
+
+      child.stdout.on("data", onStdout)
+      child.stderr.on("data", onStderr)
+
+      const timer = setTimeout(killTree, args.timeout ?? BASH_TIMEOUT_MS)
+      if (ctx.signal) {
+        ctx.signal.addEventListener("abort", killTree, { once: true })
+      }
+      child.on("error", (error) => {
+        clearTimeout(timer)
+        resolve(truncate(`Command failed: ${error.message}\n[stdout]:\n${outBuf || "(empty)"}`))
+      })
+      child.on("close", (code, signal) => {
+        clearTimeout(timer)
+        // 冲刷解码器尾部
+        outBuf += sanitizeOutput(outDecoder(Buffer.alloc(0), true))
+        errBuf += sanitizeOutput(errDecoder(Buffer.alloc(0), true))
+        const status = signal
+          ? `killed: ${ctx.signal?.aborted ? "user interrupted" : "timeout"}`
+          : `exit code ${code}`
+        const parts = [`[stdout]:\n${outBuf.trim() || "(empty)"}`]
+        if (errBuf.trim()) parts.push(`[stderr]:\n${errBuf.trim()}`)
+        parts.push(`(${status})`)
+        resolve(truncate(parts.join("\n\n") + truncatedNote))
+      })
+    })
+  },
+}