thincoder 0.1.0 → 0.2.0

package/README.md

@@ -19,7 +19,7 @@ ThinCoder 的 "Thin" 不是"功能单薄"，而是**思维锐利、直击要害*
 - **子 agent 并发**：`subagent` 工具派发独立子任务（隔离上下文，只带回报告），一批多个走并行通道；普通模式子 agent 只读，AUTO 模式全放行
 - **AUTO 模式**：`/auto` 或 `chat --auto` 完全授权，长任务免确认，状态栏黄色 AUTO 标识
 - **任务跟踪**：`task` 工具让 agent 拆解多步任务并跟踪进度（pending/in_progress/done），TUI 状态栏实时显示 ▶n/m
-- **流式 TUI**：裸 ANSI 实现（无 UI 库），对话流 / 流式输出 / 权限确认 / 翻页 / 输入历史 / 斜杠命令
+- **流式 TUI**：裸 ANSI 实现（无 UI 库），对话流 / 流式输出 / 权限确认（y/n/a，a=批准并转 AUTO）/ 翻页 / 输入历史 / 斜杠命令 Tab 补全
 - **上下文压缩**：对话超阈值时自动摘要（保留最早 2 条 + 最近 10 条，中间 LLM 摘要）
 - **三层记忆 + 团队共享**（见下）
 - **LLM 调用**：原生 `fetch` 直连 OpenAI 兼容协议（OpenAI / DeepSeek / Moonshot / Ollama），流式 SSE，指数退避重试，支持 `reasoning_content` 思考流
@@ -49,38 +49,40 @@ ThinCoder 的 "Thin" 不是"功能单薄"，而是**思维锐利、直击要害*
 ## 快速开始
 
 ```bash
-# 配置（首次）
-mkdir -p ~/.thincoder
-cat > ~/.thincoder/config.json <<'EOF'
-{
-  "provider": {
-    "baseURL": "https://api.deepseek.com/v1",
-    "apiKey": "sk-...",
-    "model": "deepseek-chat"
-  }
-}
-EOF
+# 安装
+npm install -g thincoder
 
 # 启动 TUI（默认命令）
-node bin/thincoder.mjs
+thincoder
+```
+
+首次启动会自动进入初始配置向导：方向键选提供商（内置预设或自定义端点）→ 输入 API key → 可选填 embedding key（SiliconFlow，开启记忆向量检索，可跳过）→ 方向键选模型，全程不用手编配置文件。之后随时可用 `/provider`、`/model`、`/config embedkey` 调整。`chat`/`distill` 在终端下没配 key 时也会就地问答式配置（管道/CI 环境则报错退出并提示）。
+
+也可以直接手写配置 `~/.thincoder/config.json`（见下文"配置"），然后：
 
+```bash
 # 一次性问答（管道友好）
-node bin/thincoder.mjs chat "读一下 package.json 并总结"
+thincoder chat "读一下 package.json 并总结"
 
 # 记忆管理
-node bin/thincoder.mjs memory put --type=rule --title="代码规范" --content="不加分号"
-node bin/thincoder.mjs memory search "代码规范"
-node bin/thincoder.mjs memory list
-node bin/thincoder.mjs memory remove 1
+thincoder memory put --type=rule --title="代码规范" --content="不加分号"
+thincoder memory search "代码规范"
+thincoder memory list
+thincoder memory remove 1
 
 # 团队记忆（可选，配置 memory.team 后可用）
-node bin/thincoder.mjs sync                       # 拉取团队仓库并重建索引
+thincoder sync                       # 拉取团队仓库并重建索引
 
 # 从会话记录提取知识（逐条确认后入库）
-node bin/thincoder.mjs distill session.txt
+thincoder distill session.txt
+
+# 升级
+thincoder upgrade
 ```
 
-TUI 内斜杠命令：`/help`、`/model`（查看/切换模型）、`/config`（查看配置）、`/distill`（从当前会话提取知识）、`/clear`、`/exit`。输入 `/` 时状态栏实时提示匹配命令。
+从源码运行：把上面的 `thincoder` 换成 `node bin/thincoder.mjs`。
+
+TUI 内斜杠命令：`/help`、`/model`（方向键选择全部 provider 的全部模型；`/model <名称>` 直接切换）、`/provider`（增/删 provider、配 key，支持自定义端点）、`/think`（思维模式开关与推理强度）、`/config`（查看配置、`/config key` 配当前 key）、`/distill`（从当前会话提取知识）、`/clear`、`/exit`。输入 `/` 时状态栏实时提示匹配命令。
 
 环境变量：`THINCODER_API_KEY`（或 `DEEPSEEK_API_KEY` / `OPENAI_API_KEY`）、`THINCODER_BASE_URL`、`THINCODER_MODEL`、`SILICONFLOW_API_KEY`。
 
@@ -90,11 +92,15 @@ TUI 内斜杠命令：`/help`、`/model`（查看/切换模型）、`/config`（
 
 ```jsonc
 {
-  "provider": {
-    "baseURL": "https://api.deepseek.com/v1",  // 任意 OpenAI 兼容端点
-    "apiKey": "sk-...",                         // 或留空走环境变量
-    "model": "deepseek-chat"
-  },
+  "providers": [                              // 可配多个，/model <名称> 切换
+    {
+      "name": "deepseek",
+      "baseURL": "https://api.deepseek.com/v1",  // 任意 OpenAI 兼容端点
+      "apiKey": "sk-...",                         // 或留空走环境变量
+      "model": "deepseek-chat"
+    }
+  ],
+  "activeProvider": "deepseek",               // 当前激活的 provider 名
   "embedding": {                                // 可选：不配则纯 FTS 检索
     "baseURL": "https://api.siliconflow.cn/v1",
     "apiKey": "sk-...",                         // 或 SILICONFLOW_API_KEY

package/bin/thincoder.mjs

@@ -5,21 +5,31 @@
  *   thincoder                 启动 TUI
  *   thincoder chat "..."      一次性 agent 问答（可调用工具，流式输出）
  *   thincoder memory <sub>    记忆管理：list / search / put / remove
+ *   thincoder upgrade         从 npm 升级到最新版
  *   thincoder --help          显示帮助
  */
 
-import { readFileSync } from "node:fs"
+import { existsSync, readFileSync } from "node:fs"
 import { createInterface } from "node:readline"
 import { execSync } from "node:child_process"
 import { join } from "node:path"
 import { createAgent, runAgent } from "../src/agent.mjs"
-import { loadConfig, configDir } from "../src/config.mjs"
+import { loadConfig, saveConfig, configDir, configPath, PROVIDER_PRESETS } from "../src/config.mjs"
 import { createMemory, memoryTools, put, remove, search, list, syncDir } from "../src/memory.mjs"
-import { createProvider } from "../src/provider.mjs"
 import { builtinTools } from "../src/tools.mjs"
 
 const [command, ...args] = process.argv.slice(2)
 
+// 顶层兜底：任何未捕获错误打印一行消息干净退出，不糊用户一脸 stack
+process.on("uncaughtException", (error) => {
+  console.error(`[error] ${error.message}`)
+  exitSoon(1)
+})
+process.on("unhandledRejection", (error) => {
+  console.error(`[error] ${error?.message ?? error}`)
+  exitSoon(1)
+})
+
 const USAGE = `thincoder - thin coding agent
 
 Usage:
@@ -36,14 +46,25 @@ Usage:
                             transcript file; confirm each before saving
   thincoder upgrade         Update to the latest version from npm
 
-Config: ~/.thincoder/config.json (provider.baseURL / provider.apiKey / provider.model)
-Env:    THINCODER_API_KEY, THINCODER_BASE_URL, THINCODER_MODEL
+Config: ~/.thincoder/config.json (providers[] + activeProvider；TUI 内用 /provider、/model 管理)
+Env:    THINCODER_API_KEY, THINCODER_BASE_URL, THINCODER_MODEL, THINCODER_ACTIVE_PROVIDER
 `
 
+/** 缺 key 时的统一提示 */
+function noKeyMessage() {
+  return `还没有配置 API key。运行 thincoder 进入 TUI，用 /provider add 和 /provider key 配置；或直接编辑 ${configPath}`
+}
+
+/** 延迟退出：fetch 后立刻 process.exit 在 Windows/Node 24 会触发 libuv 断言，让一句柄关完再走 */
+function exitSoon(code) {
+  setTimeout(() => process.exit(code), 100)
+}
+
 /** 组装一个带记忆的 agent（同步各层索引后返回） */
 async function makeAgent() {
   const config = loadConfig()
-  const provider = createProvider(config.provider)
+  const provider = config.provider
+  const providers = config.providersList
   const memory = createMemory({ dbPath: config.memory.dbPath })
   // 向量检索：配了 embedding 就启用（惰性生成向量，首次搜索时补算）
   if (config.embedding?.apiKey) {
@@ -63,13 +84,16 @@ async function makeAgent() {
     await ensureClone(team)
     await syncDir(memory, { layer: "team", dir: team.dir })
   }
-  return createAgent({
+  const agent = createAgent({
     provider,
     tools: [...builtinTools, ...memoryTools(memory, { cwd, projectDir: config.memory.projectDir, author: gitAuthor(), team })],
     config,
     cwd,
     memory,
   })
+  agent.providers = providers
+  agent.activeProvider = config.activeProvider
+  return agent
 }
 
 /** 读取 team 配置并补全默认目录；未配置返回 null */
@@ -95,10 +119,30 @@ switch (command) {
     const prompt = args.filter((a) => a !== "--auto").join(" ").trim()
     if (!prompt) {
       console.error('Usage: thincoder chat [--auto] "<prompt>"')
-      process.exit(1)
+      exitSoon(1)
     }
 
     const agent = await makeAgent()
+    if (!agent.provider.apiKey) {
+      if (!process.stdin.isTTY) {
+        console.error(noKeyMessage())
+        exitSoon(1)
+        break
+      }
+      const p = await setupWizard()
+      if (!p) {
+        exitSoon(1)
+        break
+      }
+      agent.provider = p
+      agent.activeProvider = p.name
+      // 向导可能配了 embedding key：挂上向量检索
+      const fresh = loadConfig()
+      if (fresh.embedding?.apiKey && agent.memory && !agent.memory.embedder) {
+        const { createEmbedder } = await import("../src/embedding.mjs")
+        agent.memory.embedder = createEmbedder(fresh.embedding)
+      }
+    }
     if (auto) agent.autoApprove = true
     try {
       await runAgent(agent, prompt, {
@@ -116,7 +160,7 @@ switch (command) {
       process.stdout.write("\n")
     } catch (error) {
       console.error(`\n[error] ${error.message}`)
-      process.exit(1)
+      exitSoon(1)
     }
     break
   }
@@ -141,7 +185,7 @@ switch (command) {
     if (!team) {
       console.error("Team memory not configured. Set memory.team in ~/.thincoder/config.json:")
       console.error('  "team": { "name": "myteam", "repo": "git@github.com:org/team-memory.git" }')
-      process.exit(1)
+      exitSoon(1)
     }
     const memory = createMemory({ dbPath: config.memory.dbPath })
     const { ensureClone, pullTeam } = await import("../src/gitmem.mjs")
@@ -153,7 +197,7 @@ switch (command) {
       console.log(`Synced. Index: +${stats.added} ~${stats.updated} -${stats.removed}`)
     } catch (error) {
       console.error(`[error] ${error.message}`)
-      process.exit(1)
+      exitSoon(1)
     }
     break
   }
@@ -169,19 +213,38 @@ switch (command) {
     const file = positional[0]
     if (!file) {
       console.error("Usage: thincoder distill <transcript-file> [--yes] [--scope=personal|project|team]")
-      process.exit(1)
+      exitSoon(1)
     }
     const { readFile } = await import("node:fs/promises")
     const transcript = await readFile(file, "utf8")
 
     const config = loadConfig()
-    const provider = createProvider(config.provider)
+    let provider = config.provider
+    if (!provider.apiKey) {
+      if (!process.stdin.isTTY) {
+        console.error(noKeyMessage())
+        exitSoon(1)
+        break
+      }
+      provider = await setupWizard()
+      if (!provider) {
+        exitSoon(1)
+        break
+      }
+    }
     const memory = createMemory({ dbPath: config.memory.dbPath })
     const team = teamConfig(config)
     const { extractCandidates, saveCandidate } = await import("../src/distill.mjs")
 
     console.error("[distill] extracting candidates...")
-    const candidates = await extractCandidates(provider, transcript)
+    let candidates
+    try {
+      candidates = await extractCandidates(provider, transcript)
+    } catch (error) {
+      console.error(`[distill] ${error.message}`)
+      exitSoon(1)
+      break
+    }
     if (candidates.length === 0) {
       console.log("No distillable knowledge found in this session.")
       break
@@ -257,7 +320,7 @@ switch (command) {
       })
     } catch (error) {
       console.error(`[error] ${error.message}`)
-      process.exit(1)
+      exitSoon(1)
     }
     break
   }
@@ -270,7 +333,7 @@ switch (command) {
       remote = execSync("npm view thincoder version", { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim()
     } catch {
       console.error("[upgrade] 无法查询 npm registry，请确认网络和 npm 已安装")
-      process.exit(1)
+      exitSoon(1)
     }
     if (remote === local) {
       console.log(`ThinCoder ${local} 已是最新。`)
@@ -291,7 +354,7 @@ switch (command) {
   default: {
     console.error(`Unknown command: ${command}\n`)
     process.stdout.write(USAGE)
-    process.exit(1)
+    exitSoon(1)
   }
 }
 
@@ -318,7 +381,7 @@ async function memoryCommand(memory, args) {
       const query = positional.join(" ")
       if (!query) {
         console.error("Usage: thincoder memory search <query>")
-        process.exit(1)
+        exitSoon(1)
       }
       printEntries(await search(memory, query, { limit: 10 }))
       break
@@ -326,7 +389,7 @@ async function memoryCommand(memory, args) {
     case "put": {
       if (!flags.type || !flags.title || !flags.content) {
         console.error("Usage: thincoder memory put --type=<rule|knowledge|decision|pattern> --title=<t> --content=<c> [--tags=<t>]")
-        process.exit(1)
+        exitSoon(1)
       }
       const id = await put(memory, { type: flags.type, title: flags.title, content: flags.content, tags: flags.tags ?? "" })
       console.log(`Saved (id=${id})`)
@@ -336,14 +399,14 @@ async function memoryCommand(memory, args) {
       const id = Number(positional[0])
       if (!id) {
         console.error("Usage: thincoder memory remove <id>")
-        process.exit(1)
+        exitSoon(1)
       }
       console.log((await remove(memory, id)) ? `Removed #${id}` : `No entry #${id}`)
       break
     }
     default:
       console.error("Usage: thincoder memory <list|search|put|remove>")
-      process.exit(1)
+      exitSoon(1)
   }
 }
 
@@ -381,3 +444,70 @@ async function askPermission(name, toolArgs) {
     rl.close()
   }
 }
+
+/** 首次使用（TTY 下的 chat/distill）：问答式配置一个 provider 并落盘，返回运行时 provider；取消返回 null */
+async function setupWizard() {
+  // 自带缓冲的提问器：rl.question 在输入被管道/快速粘贴时会丢行（问题注册前 line 已到达）
+  const rl = createInterface({ input: process.stdin, terminal: false })
+  const buffered = []
+  let waiter = null
+  rl.on("line", (line) => {
+    if (waiter) {
+      const w = waiter
+      waiter = null
+      w(line)
+    } else {
+      buffered.push(line)
+    }
+  })
+  const ask = (q) =>
+    new Promise((resolve) => {
+      process.stderr.write(q)
+      if (buffered.length) resolve(buffered.shift())
+      else waiter = resolve
+    })
+  try {
+    const presets = Object.entries(PROVIDER_PRESETS)
+    console.error("首次使用，先配置一个模型提供商：")
+    presets.forEach(([n, p], i) => console.error(`  ${i + 1}. ${n.padEnd(10)} ${p.desc}`))
+    console.error(`  ${presets.length + 1}. 自定义端点`)
+    const choice = Number((await ask(`选择 [1-${presets.length + 1}]: `)).trim())
+    let name, baseURL, model
+    if (choice === presets.length + 1) {
+      name = (await ask("名称（如 my-openai）: ")).trim()
+      baseURL = (await ask("baseURL（如 https://api.openai.com/v1）: ")).trim().replace(/\/+$/, "")
+      model = (await ask("模型（如 gpt-4o）: ")).trim()
+      if (!name || !/^https?:\/\//.test(baseURL) || !model) {
+        console.error("输入不完整或 baseURL 不合法，已取消")
+        return null
+      }
+    } else if (choice >= 1 && choice <= presets.length) {
+      name = presets[choice - 1][0]
+      baseURL = presets[choice - 1][1].baseURL
+      model = presets[choice - 1][1].model
+    } else {
+      console.error("无效选择，已取消")
+      return null
+    }
+    const apiKey = (await ask(`${name} 的 API key: `)).trim()
+    if (!apiKey) {
+      console.error("key 不能为空，已取消")
+      return null
+    }
+    const embedKey = (await ask("可选：embedding API key（SiliconFlow，向量检索用；回车跳过）: ")).trim()
+    const raw = existsSync(configPath) ? JSON.parse(readFileSync(configPath, "utf8")) : {}
+    const providers = raw.providers?.length ? raw.providers : []
+    const existing = providers.find((p) => p.name === name)
+    if (existing) Object.assign(existing, { baseURL, model, apiKey })
+    else providers.push({ name, baseURL, model, apiKey })
+    raw.providers = providers
+    raw.activeProvider = name
+    if (embedKey) raw.embedding = { ...(raw.embedding ?? {}), apiKey: embedKey }
+    saveConfig(raw)
+    console.error(`配置完成：${name} / ${model}（已写入 ${configPath}）`)
+    console.error(embedKey ? "向量检索已启用\n" : "（未配 embedding key：记忆为纯文本检索，之后在 config.json 的 embedding.apiKey 补上即可开启向量检索）\n")
+    return { name, baseURL, model, apiKey }
+  } finally {
+    rl.close()
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thincoder",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Thin coding agent - zero dependencies, no build step, Node.js native. Sharp code, zero bloat.",
   "keywords": ["ai", "agent", "coding", "cli", "llm", "deepseek", "openai", "tui"],
   "type": "module",

package/src/agent.mjs

@@ -14,9 +14,12 @@ import { join } from "node:path"
 const DEFAULT_MAX_TURNS = 50
 
 /**
- * 修复断头 tool_calls：assistant 消息带了 tool_calls 但后面缺对应的 tool 结果
- * （进程在工具执行中途被杀、会话中断等）。为每个缺失的 tool_call_id 补一条
- * 中断占位消息，否则 API 会整单拒绝（invalid_request_error）。
+ * 修复历史里的两类毒数据（都会让 API 整单拒绝 invalid_request_error）：
+ * 1. 空 assistant 消息：无正文、无 tool_calls（思考流跑完正文为空、被截断时可能产生），
+ *    直接丢弃——"assistant must not be empty"。
+ * 2. 断头 tool_calls：assistant 消息带了 tool_calls 但后面缺对应的 tool 结果
+ *    （进程在工具执行中途被杀、会话中断等）。为每个缺失的 tool_call_id 补一条
+ *    中断占位消息。
  * 返回修复后的新数组；无问题时返回原数组。
  */
 export function repairHistory(history) {
@@ -24,6 +27,11 @@ export function repairHistory(history) {
   let dirty = false
   for (let i = 0; i < history.length; i++) {
     const m = history[i]
+    // 空 assistant 消息：无正文且无 tool_calls，丢弃
+    if (m.role === "assistant" && !m.tool_calls?.length && !m.content) {
+      dirty = true
+      continue
+    }
     out.push(m)
     if (m.role !== "assistant" || !m.tool_calls?.length) continue
 
@@ -245,6 +253,10 @@ export async function runAgent(agent, input, callbacks = {}, { depth = 0 } = {})
 
     // 无工具调用：最终回答，收尾
     if (response.toolCalls.length === 0) {
+      // 空回复（思考流跑完正文为空、被截断等）不入历史——空 assistant 消息会毒害后续所有请求
+      if (!response.content) {
+        throw new Error("LLM 返回了空回复（可能是思考耗尽或被截断）。可 /think effort 降低推理强度后重试")
+      }
       agent.history.push({ role: "assistant", content: response.content })
       return response.content
     }

package/src/config.mjs

@@ -1,6 +1,8 @@
 /**
  * config.mjs — 配置加载与保存
- * 配置文件：~/.thincoder/config.json；API key 可用环境变量兜底。
+ * 多 provider 结构：providers[] + activeProvider
+ * 配置文件：~/.thincoder/config.json
+ * API key 可用环境变量兜底（未在 providers 中配置时）。
  */
 
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs"
@@ -10,11 +12,20 @@ import { join } from "node:path"
 export const configDir = join(homedir(), ".thincoder")
 export const configPath = join(configDir, "config.json")
 
+/** 内置提供商预设：/provider add <预设名>、首次启动向导共用 */
+export const PROVIDER_PRESETS = {
+  deepseek: { baseURL: "https://api.deepseek.com/v1", model: "deepseek-v4-pro", thinking: { type: "enabled" }, reasoningEffort: "max", desc: "DeepSeek" },
+  kimi:     { baseURL: "https://api.moonshot.cn/v1", model: "kimi-k3", thinking: null, reasoningEffort: "high", desc: "Kimi / Moonshot" },
+  glm:      { baseURL: "https://open.bigmodel.cn/api/paas/v4", model: "glm-5.2", thinking: { type: "enabled" }, reasoningEffort: "max", desc: "智谱 GLM" },
+  qwen:     { baseURL: "https://dashscope.aliyuncs.com/compatible-mode/v1", model: "qwen-plus", desc: "通义千问" },
+}
+
+// 默认 provider 跟 deepseek 预设保持一致（去掉 desc 展示字段）
+const { desc: _presetDesc, ...deepseekPreset } = PROVIDER_PRESETS.deepseek
+
 const DEFAULTS = {
-  provider: {
-    baseURL: "https://api.deepseek.com/v1",
-    model: "deepseek-chat",
-  },
+  providers: [{ name: "deepseek", ...deepseekPreset }],
+  activeProvider: "deepseek",
   agent: {
     maxTurns: 50,
     compactThreshold: 100000,
@@ -39,8 +50,11 @@ const MODEL_CONTEXT_WINDOWS = [
   ["deepseek-v4-flash", 256_000],
   ["deepseek-reasoner", 64_000],
   ["deepseek-chat", 64_000],
-  ["moonshot", 256_000],
-  ["kimi", 256_000],
+  ["kimi-k3", 256_000],
+  ["kimi-k2", 128_000],
+  ["moonshot", 128_000],
+  ["glm-5", 1_000_000],
+  ["glm-4", 128_000],
   ["gpt-4.1", 1_000_000],
   ["gpt-4o", 128_000],
   ["qwen", 128_000],
@@ -63,43 +77,90 @@ export function resolveCompactThreshold(explicit, model) {
 }
 
 /**
- * 加载配置：文件 + 环境变量兜底（key 不明文落盘时走 env）。
- * 环境变量优先级：THINCODER_API_KEY > DEEPSEEK_API_KEY > OPENAI_API_KEY
+ * 从 providers[] 中按 name 查找，找不到返回第一个
+ */
+export function findProvider(providers, name) {
+  if (name) {
+    const found = providers.find((p) => p.name === name)
+    if (found) return found
+  }
+  return providers[0] ?? { name: "default", baseURL: "", model: "" }
+}
+
+/**
+ * 加载配置。
+ * 环境变量优先级：THINCODER_ACTIVE_PROVIDER > 配置文件 activeProvider
+ * THINCODER_API_KEY / THINCODER_BASE_URL / THINCODER_MODEL 覆盖当前激活 provider 的对应字段
  */
 export function loadConfig() {
   let config = {}
   if (existsSync(configPath)) {
-    config = JSON.parse(readFileSync(configPath, "utf8"))
+    try {
+      config = JSON.parse(readFileSync(configPath, "utf8"))
+    } catch (error) {
+      throw new Error(`配置文件不是合法 JSON，请检查或删除: ${configPath}\n  ${error.message}`)
+    }
   }
 
   const merged = {
     ...DEFAULTS,
     ...config,
-    provider: { ...DEFAULTS.provider, ...config.provider },
+    providers: config.providers?.length ? config.providers : DEFAULTS.providers,
+    activeProvider: config.activeProvider ?? DEFAULTS.activeProvider,
     agent: { ...DEFAULTS.agent, ...config.agent },
     memory: { ...DEFAULTS.memory, ...config.memory },
     embedding: { ...DEFAULTS.embedding, ...config.embedding },
   }
 
-  if (!merged.provider.apiKey) {
-    merged.provider.apiKey =
+  // baseURL 尾斜杠归一化（防拼出 //chat/completions）
+  for (const p of merged.providers) {
+    if (p.baseURL) p.baseURL = p.baseURL.replace(/\/+$/, "")
+  }
+
+  // 环境变量覆盖 activeProvider
+  if (process.env.THINCODER_ACTIVE_PROVIDER) {
+    merged.activeProvider = process.env.THINCODER_ACTIVE_PROVIDER
+  }
+
+  // 获取当前激活的 provider
+  const active = findProvider(merged.providers, merged.activeProvider)
+
+  // 构建运行时 provider 对象（供 agent.provider 使用）
+  const runtimeProvider = { ...active }
+
+  // 环境变量覆盖当前激活 provider 的字段
+  if (process.env.THINCODER_API_KEY) runtimeProvider.apiKey = process.env.THINCODER_API_KEY
+  if (process.env.THINCODER_BASE_URL) runtimeProvider.baseURL = process.env.THINCODER_BASE_URL
+  if (process.env.THINCODER_MODEL) runtimeProvider.model = process.env.THINCODER_MODEL
+
+  // apiKey 还可用通用环境变量兜底（当 providers 里没配 key 时）
+  if (!runtimeProvider.apiKey) {
+    runtimeProvider.apiKey =
       process.env.THINCODER_API_KEY || process.env.DEEPSEEK_API_KEY || process.env.OPENAI_API_KEY
   }
-  if (process.env.THINCODER_BASE_URL) merged.provider.baseURL = process.env.THINCODER_BASE_URL
-  if (process.env.THINCODER_MODEL) merged.provider.model = process.env.THINCODER_MODEL
+
+  // embedding apiKey
   if (!merged.embedding.apiKey) {
     merged.embedding.apiKey = process.env.SILICONFLOW_API_KEY || process.env.THINCODER_EMBEDDING_API_KEY
   }
 
-  // 压缩阈值跟模型走：配置文件显式设置的优先，否则按模型上下文窗口自动推导
+  // 压缩阈值跟模型走
   const explicitThreshold = config.agent?.compactThreshold
-  const { value, auto } = resolveCompactThreshold(explicitThreshold, merged.provider.model)
+  const { value, auto } = resolveCompactThreshold(explicitThreshold, runtimeProvider.model)
   merged.agent.compactThreshold = value
   merged.agent.compactThresholdAuto = auto
 
+  // 回写到 merged 方便上层使用
+  merged.provider = runtimeProvider
+  merged.providersList = merged.providers
+
   return merged
 }
 
+/**
+ * 保存配置。保留 providers 列表结构和 activeProvider 指针。
+ * providers[i].apiKey 仅在显式传入时才写入（不覆盖环境变量兜底的 key）
+ */
 export function saveConfig(config) {
   mkdirSync(configDir, { recursive: true })
   writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n", "utf8")

package/src/provider.mjs

@@ -8,7 +8,9 @@ export const RETRYABLE_STATUS = new Set([408, 409, 425, 429, 500, 502, 503, 504]
 const MAX_RETRIES = 3
 
 /**
- * 创建 provider。config: { baseURL, apiKey, model, maxTokens?, temperature? }
+ * 创建 provider。config: { baseURL, apiKey, model, maxTokens?, temperature?, thinking?, reasoningEffort? }
+ * thinking: { type: "enabled"|"disabled" }  思维模式开关
+ * reasoningEffort: "low"|"high"|"max"       推理强度（DeepSeek/Kimi/GLM 通用）
  */
 export function createProvider(config) {
   if (!config?.baseURL) throw new Error("provider config: baseURL is required")
@@ -20,6 +22,8 @@ export function createProvider(config) {
     model: config.model,
     maxTokens: config.maxTokens,
     temperature: config.temperature,
+    thinking: config.thinking,
+    reasoningEffort: config.reasoningEffort,
   }
 }
 
@@ -40,6 +44,8 @@ export async function chat(provider, { messages, tools, onToken, onReasoning, si
   }
   if (provider.maxTokens) body.max_tokens = provider.maxTokens
   if (provider.temperature != null) body.temperature = provider.temperature
+  if (provider.thinking) body.thinking = provider.thinking
+  if (provider.reasoningEffort) body.reasoning_effort = provider.reasoningEffort
   if (tools?.length) body.tools = tools
 
   const response = await requestWithRetry(provider, body, signal)

package/src/session.mjs

@@ -17,9 +17,9 @@ export function sessionPath(cwd) {
 /** 保存会话（同步：退出清理路径也能用） */
 export function saveSession(agent) {
   const data = {
-    version: 1,
+    version: 2,
     cwd: agent.cwd,
-    model: agent.provider.model,
+    activeProvider: agent.provider?.name,
     updatedAt: Date.now(),
     history: agent.history,
     tasks: agent.tasks ?? [],
@@ -35,7 +35,8 @@ export function loadSession(cwd) {
     const p = sessionPath(cwd)
     if (!existsSync(p)) return null
     const data = JSON.parse(readFileSync(p, "utf8"))
-    if (data?.version !== 1 || !Array.isArray(data.history)) return null
+    if (data?.version !== 1 && data?.version !== 2) return null
+    if (!Array.isArray(data.history)) return null
     return data
   } catch {
     return null
@@ -46,7 +47,7 @@ export function loadSession(cwd) {
 export function clearSession(cwd) {
   try {
     const p = sessionPath(cwd)
-    if (existsSync(p)) writeFileSync(p, JSON.stringify({ version: 1, cwd, history: [], tasks: [] }), "utf8")
+    if (existsSync(p)) writeFileSync(p, JSON.stringify({ version: 2, cwd, history: [], tasks: [] }), "utf8")
   } catch {
     // 清不掉就算了，下次保存会覆盖
   }