chainlesschain 0.162.107 → 0.162.109

package/src/commands/hub.js

@@ -15,6 +15,7 @@
  * All output supports --json for scripting. Default is human-readable.
  */
 
+import { readFileSync, writeFileSync } from "node:fs";
 import chalk from "chalk";
 import ora from "ora";
 import { logger } from "../lib/logger.js";
@@ -528,7 +529,7 @@ async function cmdQueryEvents(options) {
     // skips the 77-adapter registry build (and is crash-resilient to a
     // partial pdh install). getHubMinimal() returns the full hub if one was
     // already built this process, so the vault instance is identical.
-    const hub = await getHubMinimal();
+    const hub = await (options._getHub || getHubMinimal)();
     const q = {};
     if (options.subtype) q.subtype = options.subtype;
     if (options.since) q.since = Number(options.since);
@@ -543,10 +544,18 @@ async function cmdQueryEvents(options) {
     }
     logger.log(`${events.length} events:`);
     for (const ev of events) {
-      const at = new Date(ev.at).toISOString();
-      logger.log(
-        `  ${chalk.gray(at)} ${chalk.cyan(ev.subtype)} ${ev.summary || ev.id}`,
-      );
+      // Vault events carry `occurredAt` (epoch ms) + `content`, NOT `at` /
+      // `summary` — reading the wrong fields previously threw "Invalid time
+      // value" on the first row and killed the whole listing. Guard the
+      // timestamp so one malformed row can't crash the output.
+      const ts = Number(ev.occurredAt);
+      const at = Number.isFinite(ts) ? new Date(ts).toISOString() : "(no date)";
+      const summary =
+        (ev.content &&
+          (ev.content.text || ev.content.title || ev.content.subject)) ||
+        ev.summary ||
+        ev.id;
+      logger.log(`  ${chalk.gray(at)} ${chalk.cyan(ev.subtype)} ${summary}`);
     }
     process.exit(0);
   } catch (err) {
@@ -601,7 +610,9 @@ async function cmdExportEvents(options) {
     const hub = await (options._getHub || getHubMinimal)();
     const all = exportAllEvents(hub.vault);
     if (options.output) {
-      require("fs").writeFileSync(options.output, JSON.stringify(all), "utf-8");
+      // ESM module — must NOT use require("fs") (ReferenceError: require is
+      // not defined). Use the static node:fs import.
+      writeFileSync(options.output, JSON.stringify(all), "utf-8");
       if (options.json) {
         jsonAndExit({ ok: true, count: all.length, output: options.output });
         return;
@@ -623,7 +634,8 @@ async function cmdImportEvents(options) {
         "import-events: --input <file> is required (a JSON array of events)",
       );
     }
-    const raw = require("fs").readFileSync(options.input, "utf-8");
+    // ESM module — use the static node:fs import, not require("fs").
+    const raw = readFileSync(options.input, "utf-8");
     const events = JSON.parse(raw);
     if (!Array.isArray(events)) {
       throw new Error("import-events: expected a JSON array of events");
@@ -789,7 +801,7 @@ async function cmdEventDetail(eventId, options) {
   }
   try {
     // Read-only single-event lookup — vault-only, use the minimal hub.
-    const hub = await getHubMinimal();
+    const hub = await (options._getHub || getHubMinimal)();
     const event = hub.vault.getEvent(eventId);
     if (!event) {
       const result = { found: false, eventId };
@@ -802,9 +814,24 @@ async function cmdEventDetail(eventId, options) {
     } else {
       logger.log(chalk.bold(`event ${event.id}`));
       logger.log(`  subtype:  ${event.subtype}`);
-      logger.log(`  source:   ${event.source}`);
-      if (event.title) logger.log(`  title:    ${event.title}`);
+      // occurredAt (epoch ms) is the canonical timestamp; guard a bad value.
+      const ts = Number(event.occurredAt);
+      if (Number.isFinite(ts)) {
+        logger.log(`  occurred: ${new Date(ts).toISOString()}`);
+      }
+      // `source` is an object ({ adapter, ... }) — print the adapter, not the
+      // object (which renders as "[object Object]").
+      const adapter =
+        event.source && typeof event.source === "object"
+          ? event.source.adapter
+          : event.source;
+      if (adapter) logger.log(`  source:   ${adapter}`);
       if (event.actor) logger.log(`  actor:    ${event.actor}`);
+      const summary =
+        event.content &&
+        (event.content.text || event.content.title || event.content.subject);
+      if (summary) logger.log(`  content:  ${summary}`);
+      if (event.title) logger.log(`  title:    ${event.title}`);
       if (event.amount != null) {
         logger.log(`  amount:   ${event.amount} ${event.currency || ""}`);
       }
@@ -3263,6 +3290,8 @@ export const _internal = {
   cmdRetrieveContext,
   cmdStats,
   cmdHealth,
+  cmdQueryEvents,
+  cmdEventDetail,
   parsePositiveInt,
   cmdAIChatList,
   cmdAIChatLogin,

package/src/commands/mcp.js

@@ -23,6 +23,8 @@ import {
   SUPPORTED_TRANSPORTS,
 } from "../lib/mcp-scaffold.js";
 import { parseJsonOption } from "../lib/parse-json-option.js";
+import { resolveMcpAuthTarget, isUrlLike } from "../lib/mcp-auth-target.js";
+import { notFoundWithSuggestion } from "../lib/suggest-name.js";
 import {
   CATALOG as REGISTRY_CATALOG,
   CATEGORIES as REGISTRY_CATEGORIES,
@@ -39,6 +41,27 @@ function getClient() {
   return mcpClient;
 }
 
+/**
+ * Resolve a `mcp login|logout <target>` argument (a URL or a configured server
+ * NAME — Claude-Code 2.1.186 parity) to a concrete server URL. The DB is only
+ * bootstrapped when a name lookup is actually needed, so a raw-URL login stays
+ * dependency-free.
+ */
+async function resolveAuthTargetUrl(program, target) {
+  if (isUrlLike(target)) return resolveMcpAuthTarget(target).url;
+  const ctx = await bootstrap({ verbose: program.opts().verbose });
+  const lookup = (name) => {
+    try {
+      return ctx.db
+        ? new MCPServerConfig(ctx.db.getDatabase()).get(name)
+        : null;
+    } catch {
+      return null; // a lookup failure surfaces as "unknown server" below
+    }
+  };
+  return resolveMcpAuthTarget(target, lookup).url;
+}
+
 /**
  * Connect MCP server(s) for a one-shot query (resources / prompts). Connects
  * the named server, or every registered server when `serverName` is omitted.
@@ -56,8 +79,9 @@ async function connectForQuery(program, serverName) {
   if (serverName) {
     const row = config.get(serverName);
     if (!row) {
+      const names = config.list().map((s) => s.name);
       logger.error(
-        `Server "${serverName}" not configured. Use 'mcp add' first.`,
+        `${notFoundWithSuggestion(serverName, names, { noun: "Server" })}. Use 'mcp add' first.`,
       );
       await shutdown();
       process.exit(1);
@@ -111,9 +135,9 @@ export function registerMcpCommand(program) {
 
   // mcp login — OAuth 2.0 (Auth Code + PKCE) for a remote MCP server.
   mcp
-    .command("login <url>")
+    .command("login <target>")
     .description(
-      "Authorize a remote MCP server via OAuth (opens a browser); stores the token",
+      "Authorize a remote MCP server via OAuth (opens a browser); stores the token. <target> is a URL or a configured server name.",
     )
     .option("--scope <scope>", "OAuth scope(s) to request")
     .option(
@@ -127,8 +151,9 @@ export function registerMcpCommand(program) {
       53682,
     )
     .option("--no-open", "Print the authorize URL instead of opening a browser")
-    .action(async (url, options) => {
+    .action(async (target, options) => {
       try {
+        const url = await resolveAuthTargetUrl(program, target);
         const oauth = await import("../lib/mcp-oauth.js");
         if (options.open === false) {
           oauth._deps.openBrowser = () => false; // commander maps --no-open → open:false
@@ -159,10 +184,13 @@ export function registerMcpCommand(program) {
 
   // mcp logout — forget a stored OAuth token.
   mcp
-    .command("logout <url>")
-    .description("Delete the stored OAuth token for a remote MCP server")
-    .action(async (url) => {
+    .command("logout <target>")
+    .description(
+      "Delete the stored OAuth token for a remote MCP server (<target> is a URL or a configured server name)",
+    )
+    .action(async (target) => {
       try {
+        const url = await resolveAuthTargetUrl(program, target);
         const { deleteStoredToken, serverKey } =
           await import("../lib/mcp-oauth.js");
         const ok = deleteStoredToken(url);
@@ -199,7 +227,7 @@ export function registerMcpCommand(program) {
         }
         if (rows.length === 0) {
           logger.log(
-            chalk.gray("No MCP OAuth tokens. Run: cc mcp login <url>"),
+            chalk.gray("No MCP OAuth tokens. Run: cc mcp login <name|url>"),
           );
           return;
         }
@@ -497,12 +525,13 @@ export function registerMcpCommand(program) {
 
         const db = ctx.db.getDatabase();
         const config = new MCPServerConfig(db);
+        const names = config.list().map((s) => s.name);
         const removed = config.remove(name);
 
         if (removed) {
           logger.success(`MCP server "${name}" removed`);
         } else {
-          logger.error(`Server "${name}" not found`);
+          logger.error(notFoundWithSuggestion(name, names, { noun: "Server" }));
         }
 
         await shutdown();
@@ -533,7 +562,10 @@ export function registerMcpCommand(program) {
         const serverConfig = config.get(name);
 
         if (!serverConfig) {
-          logger.error(`Server "${name}" not configured. Use 'mcp add' first.`);
+          const names = config.list().map((s) => s.name);
+          logger.error(
+            `${notFoundWithSuggestion(name, names, { noun: "Server" })}. Use 'mcp add' first.`,
+          );
           process.exit(1);
         }
 

package/src/commands/pdh.js

@@ -23,11 +23,125 @@ import {
   pdhLockDir,
   diagnosePdh,
 } from "../lib/pdh-bridge.js";
+import { setupMcpFromConfig } from "../runtime/mcp-config.js";
+import {
+  readFeedback,
+  summarizeFeedback,
+} from "../lib/pdh-feedback-ledger.js";
 
 function emit(obj) {
   console.log(JSON.stringify(obj, null, 2));
 }
 
+/** Concatenate the text blocks of an MCP tool result, else null. */
+function mcpResultText(r) {
+  if (!r) return null;
+  if (Array.isArray(r.content)) {
+    const t = r.content
+      .filter((b) => b && b.type === "text" && typeof b.text === "string")
+      .map((b) => b.text)
+      .join("");
+    if (t) return t;
+  }
+  if (typeof r.result === "string") return r.result;
+  return null;
+}
+
+async function safeDisconnectAll(out) {
+  try {
+    await out?.mcpClient?.disconnectAll?.();
+  } catch {
+    /* best-effort cleanup */
+  }
+}
+
+/**
+ * Live connectivity probe for the discovered PDH bridge — the cc-side
+ * diagnostic the list/status/doctor inspectors lack: list/status/doctor only
+ * read lockfiles, this actually **connects** and verifies the server responds
+ * (discover → connect → `pdh_ping` round-trip → report). Best-effort; always
+ * disconnects. The result NEVER carries the bearer token. Injectable for tests.
+ *
+ * @returns {Promise<object>} { ok, stage, reason?, device?, port?, transport?,
+ *   tools?, latencyMs?, pingAttempted?, pingOk?, pingText?, pingError? }
+ */
+export async function probePdhBridge(opts = {}, deps = {}) {
+  const env = opts.env || process.env;
+  const discover = deps.discoverPdhServer || discoverPdhServer;
+  const connect = deps.setupMcpFromConfig || setupMcpFromConfig;
+  const now = deps.now || (() => Date.now());
+
+  const lock = discover({ env });
+  if (!lock) {
+    return {
+      ok: false,
+      stage: "discover",
+      reason: "no live PDH server discovered (run `cc pdh doctor`)",
+    };
+  }
+  const base = {
+    device: lock.device,
+    port: lock.port,
+    transport: lock.transport,
+  };
+  const cfg = pdhServerToMcpConfig(lock);
+  const start = now();
+  let out;
+  try {
+    out = await connect({ pdh: cfg }, { writeErr: () => {} });
+  } catch (err) {
+    return { ok: false, stage: "connect", reason: err.message, ...base };
+  }
+  const conn = (out.connected || []).find((c) => c.server === "pdh");
+  if (!conn) {
+    await safeDisconnectAll(out);
+    return {
+      ok: false,
+      stage: "connect",
+      reason: "server did not connect (no tools)",
+      ...base,
+    };
+  }
+  // The bare tool names the bridge exposes (mcp__pdh__collect_files →
+  // collect_files), so the probe shows WHICH collectors a device advertises —
+  // confirming the bridge version/capabilities, not just a count.
+  const toolNames = (out.extraToolDefinitions || [])
+    .map((t) => t && t.function && t.function.name)
+    .filter((n) => typeof n === "string")
+    .map((n) =>
+      n.startsWith("mcp__pdh__") ? n.slice("mcp__pdh__".length) : n,
+    );
+  // Round-trip via pdh_ping when the bridge exposes it; otherwise the
+  // tools/list that connect already performed is itself proof of liveness.
+  const hasPing = toolNames.includes("pdh_ping");
+  let pingOk = null;
+  let pingText = null;
+  let pingError = null;
+  if (hasPing) {
+    try {
+      const r = await out.mcpClient.callTool("pdh", "pdh_ping", {});
+      pingOk = !r?.isError;
+      pingText = mcpResultText(r);
+    } catch (err) {
+      pingOk = false;
+      pingError = err.message;
+    }
+  }
+  await safeDisconnectAll(out);
+  return {
+    ok: pingOk !== false, // connected; an attempted ping must not have failed
+    stage: "ping",
+    ...base,
+    tools: conn.tools,
+    toolNames,
+    latencyMs: now() - start,
+    pingAttempted: hasPing,
+    pingOk,
+    pingText,
+    pingError,
+  };
+}
+
 /** Strip the raw bearer token + internal _file path from a lock for output. */
 function redactLock(lock) {
   if (!lock) return null;
@@ -35,7 +149,8 @@ function redactLock(lock) {
   return { ...rest, hasToken: !!token };
 }
 
-export function registerPdhCommand(program) {
+export function registerPdhCommand(program, deps = {}) {
+  const probe = deps.probePdhBridge || probePdhBridge;
   const pdh = program
     .command("pdh")
     .description(
@@ -158,5 +273,80 @@ export function registerPdhCommand(program) {
       console.log(`  reason         : ${diag.reason}`);
     });
 
+  pdh
+    .command("ping")
+    .description(
+      "Connect to the discovered PDH server and verify it responds (pdh_ping round-trip)",
+    )
+    .option("--json", "Machine-readable output")
+    .action(async (options) => {
+      const res = await probe({ env: process.env });
+      if (options.json) {
+        emit(res);
+      } else if (res.stage === "discover") {
+        console.log(
+          chalk.yellow("No PDH server discovered.") +
+            chalk.gray(" Run `cc pdh doctor` for why."),
+        );
+      } else if (!res.ok) {
+        console.log(
+          chalk.red(
+            `PDH ${res.device}:${res.port} — ${res.stage} failed: ` +
+              `${res.reason || res.pingError || "unknown"}`,
+          ),
+        );
+      } else {
+        const tag = res.pingAttempted
+          ? res.pingOk
+            ? chalk.green("pong")
+            : chalk.red("ping failed")
+          : chalk.gray("connected (no pdh_ping tool)");
+        console.log(
+          `PDH ${chalk.cyan(res.device)}:${res.port} ${chalk.green("OK")} — ` +
+            `${tag}, ${res.tools} tools, ${res.latencyMs}ms`,
+        );
+        if (res.toolNames && res.toolNames.length) {
+          console.log(chalk.gray("  tools: " + res.toolNames.join(", ")));
+        }
+        if (res.pingText) console.log(chalk.gray("  " + res.pingText));
+      }
+      if (!res.ok) process.exitCode = 1;
+    });
+
+  pdh
+    .command("feedback")
+    .description(
+      "Show what cc has learned from your cross-session corrections (§3.5.13 flywheel)",
+    )
+    .option("--json", "Machine-readable output")
+    .action((options) => {
+      const read = deps.readFeedback || readFeedback;
+      const summarize = deps.summarizeFeedback || summarizeFeedback;
+      const summary = summarize(read());
+      if (options.json) {
+        emit(summary);
+        return;
+      }
+      // Honest empty state (§3.5.18: surface "尚无" truthfully, never hide).
+      if (!summary.total) {
+        console.log(
+          chalk.gray("尚无跨会话反馈记录 (no cross-session feedback yet)."),
+        );
+        return;
+      }
+      console.log(chalk.bold(`PDH 自学习反馈 (${summary.total} 条)`));
+      console.log(
+        `  ${chalk.green("👍 " + summary.positive)}  ` +
+          `${chalk.red("👎 " + summary.negative)}  ` +
+          `净倾向 ${summary.sentiment >= 0 ? "+" : ""}${summary.sentiment}`,
+      );
+      if (summary.corrections.length) {
+        console.log(chalk.bold("  已记住的纠正 (最新优先):"));
+        for (const c of summary.corrections) {
+          console.log(chalk.gray(`    • ${c}`));
+        }
+      }
+    });
+
   return pdh;
 }

package/src/constants.js

@@ -30,7 +30,7 @@ export const LLM_PROVIDERS = {
   volcengine: {
     name: "Volcengine (火山引擎/豆包)",
     defaultBaseUrl: "https://ark.cn-beijing.volces.com/api/v3",
-    defaultModel: "doubao-seed-1-6-251015",
+    defaultModel: "doubao-seed-2-1-pro-260628",
     requiresApiKey: true,
   },
   openai: {
@@ -144,7 +144,7 @@ export const DEFAULT_CONFIG = {
     provider: "volcengine",
     apiKey: null,
     baseUrl: "https://ark.cn-beijing.volces.com/api/v3",
-    model: "doubao-seed-1-6-251015",
+    model: "doubao-seed-2-1-pro-260628",
     // When true, `cc ask` (provider=ollama only) overrides baseUrl to point at
     // the Android LocalLlmServer (127.0.0.1:18484). User opt-in toggle:
     //   cc config set llm.preferAndroidLocal true

package/src/gateways/ws/video-protocol.js

@@ -8,6 +8,13 @@
  * Route keys use dot-case: video.assets.list, video.deconstruct, etc.
  */
 
+import { createRequire } from "node:module";
+// ESM module — `require` is not a global here. createRequire gives a working
+// require() for the lazy loads below (VideoPipeline + node core modules, kept
+// lazy so importing this protocol module doesn't pull the video stack on
+// every `cc` startup). Node >=22.12 (our engines floor) supports require(esm).
+const require = createRequire(import.meta.url);
+
 function ok(data = {}) {
   return { ok: true, ...data };
 }

package/src/harness/feature-flags.js

@@ -8,7 +8,13 @@
  *   - object { enabled, variant, description }
  */
 
-import { loadConfig, getConfigValue, saveConfig } from "../lib/config-manager.js";
+import {
+  loadConfig,
+  getConfigValue,
+  saveConfig,
+} from "../lib/config-manager.js";
+import { withFileLock } from "../lib/with-file-lock.js";
+import { getConfigPath } from "../lib/paths.js";
 import { createHash } from "node:crypto";
 import { hostname } from "node:os";
 
@@ -51,7 +57,8 @@ export function feature(name) {
   if (value && typeof value === "object") return Boolean(value.enabled);
   const defaultValue = _getDefault(name);
   if (typeof defaultValue === "boolean") return defaultValue;
-  if (typeof defaultValue === "number") return _percentageCheck(name, defaultValue);
+  if (typeof defaultValue === "number")
+    return _percentageCheck(name, defaultValue);
   if (defaultValue && typeof defaultValue === "object") {
     return Boolean(defaultValue.enabled);
   }
@@ -106,10 +113,16 @@ export function listFeatures() {
 }
 
 export function setFeature(name, value) {
-  const config = loadConfig();
-  if (!config.features) config.features = {};
-  config.features[name] = value;
-  saveConfig(config);
+  // Serialize the read-modify-write across processes so two concurrent
+  // `cc config features enable/disable` invocations don't clobber each other
+  // (and to space out writes so the atomic rename doesn't collide). Mirrors
+  // setConfigValue; the lock is best-effort and never hangs the CLI.
+  withFileLock(getConfigPath(), () => {
+    const config = loadConfig();
+    if (!config.features) config.features = {};
+    config.features[name] = value;
+    saveConfig(config);
+  });
 }
 
 export function getFlagInfo(name) {

package/src/harness/prompt-compressor.js

@@ -77,6 +77,7 @@ export const CONTEXT_WINDOWS = {
   "moonshot-v1-32k": 32768,
   "moonshot-v1-128k": 131072,
   "doubao-seed-1-6-251015": 32768,
+  "doubao-seed-2-1-pro-260628": 32768,
   _provider_defaults: {
     ollama: 32768,
     openai: 128000,

package/src/lib/agent-core.js

@@ -3,6 +3,8 @@ export {
   AGENT_TOOLS,
   AGENT_TOOL_REGISTRY,
   MAX_SUB_AGENT_DEPTH,
+  MAX_TOOL_RESULT_CHARS,
+  capToolResultString,
   reloadSkills,
   getAgentToolDefinitions,
   getAgentToolDescriptors,

package/src/lib/config-manager.js

@@ -37,7 +37,7 @@ export function saveConfig(config) {
   const tmp = `${configPath}.${process.pid}.${Math.random().toString(36).slice(2, 8)}.tmp`;
   try {
     writeFileSync(tmp, JSON.stringify(config, null, 2) + "\n", "utf-8");
-    renameSync(tmp, configPath);
+    renameWithRetry(tmp, configPath);
   } catch (err) {
     try {
       if (existsSync(tmp)) unlinkSync(tmp);
@@ -48,6 +48,47 @@ export function saveConfig(config) {
   }
 }
 
+// On Windows, `rename` over a target that another process currently has open
+// (e.g. a concurrent `loadConfig` reader) fails with EPERM/EACCES/EBUSY instead
+// of POSIX's silent atomic replace. Under bursts of concurrent `cc config`/`cc
+// config features` invocations this surfaced as a flaky exit-1. Retry the rename
+// a few times with a short synchronous backoff so the transient lock clears;
+// the temp file is already fully written, so this stays crash-safe.
+export function renameWithRetry(tmp, target, opts = {}) {
+  const {
+    attempts = 8,
+    baseDelayMs = 15,
+    _rename = renameSync,
+    _sleep = sleepSync,
+  } = opts;
+  for (let i = 0; ; i++) {
+    try {
+      _rename(tmp, target);
+      return;
+    } catch (err) {
+      const transient =
+        err &&
+        (err.code === "EPERM" ||
+          err.code === "EACCES" ||
+          err.code === "EBUSY" ||
+          err.code === "EEXIST");
+      if (!transient || i >= attempts - 1) throw err;
+      _sleep(baseDelayMs * (i + 1));
+    }
+  }
+}
+
+function sleepSync(ms) {
+  try {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+  } catch {
+    const end = Date.now() + ms; // SharedArrayBuffer unavailable — bounded spin
+    while (Date.now() < end) {
+      /* spin */
+    }
+  }
+}
+
 export function getConfigValue(key) {
   const config = loadConfig();
   return getNestedValue(config, key);

package/src/lib/git-integration.js

@@ -3,7 +3,7 @@
  */
 
 import { execSync } from "child_process";
-import { existsSync } from "fs";
+import { existsSync, writeFileSync, chmodSync } from "fs";
 import { join } from "path";
 
 /**
@@ -236,7 +236,6 @@ export function installHooks(dir) {
 echo "ChainlessChain: pre-commit hook running"
 `;
 
-  const { writeFileSync, chmodSync } = require("fs");
   writeFileSync(hookPath, hookContent, "utf-8");
   try {
     chmodSync(hookPath, 0o755);

package/src/lib/learning/learning-hooks.js

@@ -16,6 +16,12 @@
  *   - Stateless — the trajectory ID is tracked on learningCtx
  */
 
+import { createRequire } from "node:module";
+// ESM module — `require` is not a global here. createRequire gives a working
+// require() for the lazy TrajectoryStore load below (kept lazy to avoid a
+// circular import). Node >=22.12 (our engines floor) supports require(esm).
+const require = createRequire(import.meta.url);
+
 /**
  * @typedef {object} LearningContext
  * @property {import("./trajectory-store.js").TrajectoryStore} trajectoryStore

package/src/lib/llm-providers.js

@@ -84,6 +84,8 @@ export const BUILT_IN_PROVIDERS = {
     baseUrl: "https://ark.cn-beijing.volces.com/api/v3",
     apiKeyEnv: "VOLCENGINE_API_KEY",
     models: [
+      "doubao-seed-2-1-pro-260628",
+      "doubao-seed-2-0-lite-260215",
       "doubao-seed-1-6-251015",
       "doubao-seed-1-6-flash-250828",
       "doubao-seed-1-6-lite-251015",