fix(config-agent): align agent writers with cc-switch and official Model Studio docs

- claude-code: honor CLAUDE_CONFIG_DIR; drop stale ANTHROPIC_API_KEY
- qwen-code: write $version:3; security.auth carries selectedType only
- opencode: tolerate JSONC (comments/trailing commas) via stripJsonc
- openclaw: add --context-window flag (default 256000), full cost fields,
  agents.defaults.models allowlist
- hermes: switch to official flat model.* block; api_mode only for
  anthropic endpoints
- codex: official env_key + auth.json fallback; add --wire-api flag
  (default chat, responses for supported models)

Author: lishengzxc

packages/commands/src/commands/config/agent/index.ts

@@ -11,14 +11,36 @@ const FLAGS = {
     required: true,
     choices: VALID_AGENT_NAMES,
   },
-  baseUrl: { type: "string", valueHint: "<url>", description: "API base URL", required: true },
-  apiKey: { type: "string", valueHint: "<key>", description: "API key", required: true },
+  baseUrl: {
+    type: "string",
+    valueHint: "<url>",
+    description: "API base URL",
+    required: true,
+  },
+  apiKey: {
+    type: "string",
+    valueHint: "<key>",
+    description: "API key",
+    required: true,
+  },
   model: {
     type: "string",
     valueHint: "<model>",
     description: "Default model name",
     required: true,
   },
+  contextWindow: {
+    type: "number",
+    valueHint: "<tokens>",
+    description: "OpenClaw only: model context window in tokens (default: 256000)",
+  },
+  wireApi: {
+    type: "string",
+    valueHint: "<api>",
+    description:
+      'Codex only: wire protocol — "chat" works with every model; "responses" for models supporting the Responses API (default: chat)',
+    choices: ["chat", "responses"],
+  },
 } satisfies FlagsDef;
 
 export default defineCommand({
@@ -34,7 +56,7 @@ export default defineCommand({
   async run(ctx) {
     const { settings, flags } = ctx;
     const agentName = flags.agent;
-    const { baseUrl, apiKey, model } = flags;
+    const { baseUrl, apiKey, model, contextWindow, wireApi } = flags;
     const agentDef = AGENTS[agentName];
     const format = detectOutputFormat(settings.output);
 
@@ -59,7 +81,13 @@ export default defineCommand({
       return;
     }
 
-    const params: WriteParams = { baseUrl, apiKey, model };
+    const params: WriteParams = {
+      baseUrl,
+      apiKey,
+      model,
+      contextWindow,
+      wireApi,
+    };
     const summary = agentDef.write(params);
 
     if (!settings.quiet) {

packages/commands/src/commands/config/agent/writers/claude-code.ts

@@ -5,7 +5,10 @@ import { backup, readJson, writeJsonAtomic, type AgentDef } from "./utils.ts";
 export default {
   label: "Claude Code",
   write({ baseUrl, apiKey, model }) {
-    const settingsPath = join(homedir(), ".claude", "settings.json");
+    // Claude Code honors CLAUDE_CONFIG_DIR for its settings location.
+    const configDir =
+      process.env.CLAUDE_CONFIG_DIR || join(homedir(), ".claude");
+    const settingsPath = join(configDir, "settings.json");
     const onboardingPath = join(homedir(), ".claude.json");
 
     // settings.json — merge env. Base URL + auth token connect Claude Code to
@@ -15,6 +18,9 @@ export default {
     const env = (settings.env ?? {}) as Record<string, string>;
     env.ANTHROPIC_BASE_URL = baseUrl;
     env.ANTHROPIC_AUTH_TOKEN = apiKey;
+    // AUTH_TOKEN and API_KEY are mutually exclusive credential fields — drop a
+    // stale ANTHROPIC_API_KEY so it cannot shadow the token we just wrote.
+    delete env.ANTHROPIC_API_KEY;
     env.ANTHROPIC_MODEL = model;
     env.ANTHROPIC_DEFAULT_HAIKU_MODEL = model;
     env.ANTHROPIC_DEFAULT_SONNET_MODEL = model;

packages/commands/src/commands/config/agent/writers/codex.ts

@@ -2,13 +2,19 @@ import { homedir } from "os";
 import { join } from "path";
 import { existsSync, readFileSync } from "fs";
 import { parse as parseToml, stringify as stringifyToml } from "smol-toml";
-import { backup, readJson, writeJsonAtomic, writeTextAtomic, type AgentDef } from "./utils.ts";
+import {
+  backup,
+  readJson,
+  writeJsonAtomic,
+  writeTextAtomic,
+  type AgentDef,
+} from "./utils.ts";
 
 const PROVIDER_KEY = "bailian-cli";
 
 export default {
   label: "Codex",
-  write({ baseUrl, apiKey, model }) {
+  write({ baseUrl, apiKey, model, wireApi: wireApiParam }) {
     const configPath = join(homedir(), ".codex", "config.toml");
 
     // config.toml — merge into existing config so unrelated settings
@@ -17,31 +23,39 @@ export default {
     let config: Record<string, unknown> = {};
     if (existsSync(configPath)) {
       try {
-        config = parseToml(readFileSync(configPath, "utf-8")) as Record<string, unknown>;
+        config = parseToml(readFileSync(configPath, "utf-8")) as Record<
+          string,
+          unknown
+        >;
       } catch {
         config = {};
       }
     }
 
     config.model_provider = PROVIDER_KEY;
     config.model = model;
-    config.model_reasoning_effort = "high";
-    config.disable_response_storage = true;
+
+    // wire_api: "responses" for models supporting the Responses API (e.g.
+    // qwen3.7/3.8 series); "chat" works with every model via Chat Completions.
+    const wireApi = wireApiParam === "responses" ? "responses" : "chat";
 
     const providers = (config.model_providers ?? {}) as Record<string, unknown>;
     const existing = (providers[PROVIDER_KEY] ?? {}) as Record<string, unknown>;
     providers[PROVIDER_KEY] = {
       ...existing,
       name: PROVIDER_KEY,
       base_url: baseUrl,
-      wire_api: "responses",
+      // env_key is the official-doc credential mechanism: Codex resolves the
+      // key from the OPENAI_API_KEY env var, falling back to auth.json below.
+      env_key: "OPENAI_API_KEY",
+      wire_api: wireApi,
       requires_openai_auth: true,
     };
     config.model_providers = providers;
 
     writeTextAtomic(configPath, stringifyToml(config) + "\n");
 
-    // auth.json — Codex reads OPENAI_API_KEY from here.
+    // auth.json — Codex reads OPENAI_API_KEY from here when the env var is unset.
     const authPath = join(homedir(), ".codex", "auth.json");
     backup(authPath);
     const auth = readJson(authPath);

packages/commands/src/commands/config/agent/writers/hermes.ts

@@ -2,9 +2,12 @@ import { homedir } from "os";
 import { join } from "path";
 import { existsSync, readFileSync } from "fs";
 import yaml from "yaml";
-import { backup, writeTextAtomic, isAnthropicEndpoint, type AgentDef } from "./utils.ts";
-
-const PROVIDER_NAME = "bailian-cli";
+import {
+  backup,
+  writeTextAtomic,
+  isAnthropicEndpoint,
+  type AgentDef,
+} from "./utils.ts";
 
 export default {
   label: "Hermes Agent",
@@ -16,32 +19,25 @@ export default {
     let config: Record<string, unknown> = {};
     if (existsSync(configPath)) {
       try {
-        config = (yaml.parse(readFileSync(configPath, "utf-8")) ?? {}) as Record<string, unknown>;
+        config = (yaml.parse(readFileSync(configPath, "utf-8")) ??
+          {}) as Record<string, unknown>;
       } catch {
         config = {};
       }
     }
 
-    const apiMode = isAnthropicEndpoint(baseUrl) ? "anthropic_messages" : "chat_completions";
-    const providerEntry = {
-      name: PROVIDER_NAME,
+    // Official Model Studio doc shape: a single flat `model` block holding the
+    // active endpoint + credentials. `api_mode: anthropic_messages` is required
+    // for /apps/anthropic endpoints; for the OpenAI-compatible endpoint the
+    // doc says to omit api_mode entirely (chat completions is the default).
+    const block: Record<string, unknown> = {
+      default: model,
+      provider: "custom",
       base_url: baseUrl,
       api_key: apiKey,
-      api_mode: apiMode,
-      models: [{ id: model, name: model }],
     };
-
-    // custom_providers — upsert the bailian-cli entry by name.
-    const providers = Array.isArray(config.custom_providers)
-      ? (config.custom_providers as Array<Record<string, unknown>>)
-      : [];
-    const index = providers.findIndex((entry) => entry.name === PROVIDER_NAME);
-    if (index >= 0) providers[index] = providerEntry;
-    else providers.push(providerEntry);
-    config.custom_providers = providers;
-
-    // model — select the bailian-cli provider and default model.
-    config.model = { default: model, provider: PROVIDER_NAME };
+    if (isAnthropicEndpoint(baseUrl)) block.api_mode = "anthropic_messages";
+    config.model = block;
 
     writeTextAtomic(configPath, yaml.stringify(config));
 

packages/commands/src/commands/config/agent/writers/openclaw.ts

@@ -1,10 +1,20 @@
 import { homedir } from "os";
 import { join } from "path";
-import { backup, readJson, writeJsonAtomic, isAnthropicEndpoint, type AgentDef } from "./utils.ts";
+import {
+  backup,
+  readJson,
+  writeJsonAtomic,
+  isAnthropicEndpoint,
+  type AgentDef,
+} from "./utils.ts";
+
+// Safe default when --context-window is not given: most Model Studio models
+// offer ≥256K context; users can raise it per model via the flag.
+const DEFAULT_CONTEXT_WINDOW = 256000;
 
 export default {
   label: "OpenClaw",
-  write({ baseUrl, apiKey, model }) {
+  write({ baseUrl, apiKey, model, contextWindow }) {
     const configPath = join(homedir(), ".openclaw", "openclaw.json");
 
     backup(configPath);
@@ -14,7 +24,9 @@ export default {
     const models = (config.models ?? {}) as Record<string, unknown>;
     models.mode = "merge";
     const providers = (models.providers ?? {}) as Record<string, unknown>;
-    const api = isAnthropicEndpoint(baseUrl) ? "anthropic-messages" : "openai-completions";
+    const api = isAnthropicEndpoint(baseUrl)
+      ? "anthropic-messages"
+      : "openai-completions";
     providers["bailian-cli"] = {
       baseUrl,
       apiKey,
@@ -23,26 +35,31 @@ export default {
         {
           id: model,
           name: model,
-          contextWindow: 1000000,
-          cost: { input: 0, output: 0 },
+          contextWindow: contextWindow ?? DEFAULT_CONTEXT_WINDOW,
+          cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
         },
       ],
     };
     models.providers = providers;
     config.models = models;
 
-    // agents.defaults
+    // agents.defaults — select the model and register it in the allowlist.
     const agents = (config.agents ?? {}) as Record<string, unknown>;
     const defaults = (agents.defaults ?? {}) as Record<string, unknown>;
-    defaults.model = { primary: `bailian-cli/${model}` };
+    const primary = `bailian-cli/${model}`;
+    defaults.model = { primary };
+    const allowlist = (defaults.models ?? {}) as Record<string, unknown>;
+    allowlist[primary] = allowlist[primary] ?? {};
+    defaults.models = allowlist;
     agents.defaults = defaults;
     config.agents = agents;
 
     writeJsonAtomic(configPath, config);
 
     return {
       paths: [configPath],
-      nextStep: "Run `openclaw` to start using OpenClaw with DashScope.",
+      nextStep:
+        "Run `openclaw gateway restart`, then `openclaw` to start using OpenClaw with DashScope.",
     };
   },
 } satisfies AgentDef;

packages/commands/src/commands/config/agent/writers/opencode.ts

@@ -1,19 +1,28 @@
 import { homedir } from "os";
 import { join } from "path";
-import { backup, readJson, writeJsonAtomic, isAnthropicEndpoint, type AgentDef } from "./utils.ts";
+import {
+  backup,
+  readJsonc,
+  writeJsonAtomic,
+  isAnthropicEndpoint,
+  type AgentDef,
+} from "./utils.ts";
 
 export default {
   label: "OpenCode",
   write({ baseUrl, apiKey, model }) {
     const configPath = join(homedir(), ".config", "opencode", "opencode.json");
 
+    // opencode.json is JSONC — tolerate comments and trailing commas on read.
     backup(configPath);
-    const config = readJson(configPath);
+    const config = readJsonc(configPath);
 
     if (!config.$schema) config.$schema = "https://opencode.ai/config.json";
 
     const provider = (config.provider ?? {}) as Record<string, unknown>;
-    const npm = isAnthropicEndpoint(baseUrl) ? "@ai-sdk/anthropic" : "@ai-sdk/openai-compatible";
+    const npm = isAnthropicEndpoint(baseUrl)
+      ? "@ai-sdk/anthropic"
+      : "@ai-sdk/openai-compatible";
     provider["bailian-cli"] = {
       npm,
       name: "Alibaba Cloud Model Studio",

packages/commands/src/commands/config/agent/writers/qwen-code.ts

@@ -1,6 +1,12 @@
 import { homedir } from "os";
 import { join } from "path";
-import { backup, readJson, writeJsonAtomic, isAnthropicEndpoint, type AgentDef } from "./utils.ts";
+import {
+  backup,
+  readJson,
+  writeJsonAtomic,
+  isAnthropicEndpoint,
+  type AgentDef,
+} from "./utils.ts";
 
 const ENV_KEY = "BAILIAN_CLI_API_KEY";
 
@@ -19,6 +25,9 @@ export default {
     backup(settingsPath);
     const settings = readJson(settingsPath);
 
+    // $version — Qwen Code v3 settings schema (official Model Studio doc shape).
+    settings.$version = 3;
+
     // env — API key read by the provider entry's envKey.
     const env = (settings.env ?? {}) as Record<string, string>;
     env[ENV_KEY] = apiKey;
@@ -29,7 +38,9 @@ export default {
       string,
       Array<Record<string, unknown>>
     >;
-    const entries = (providers[protocol] ?? []) as Array<Record<string, unknown>>;
+    const entries = (providers[protocol] ?? []) as Array<
+      Record<string, unknown>
+    >;
     const existing = entries.find(
       (entry) => entry.id === model && (entry.baseUrl ?? "") === baseUrl,
     );
@@ -38,18 +49,25 @@ export default {
       existing.baseUrl = baseUrl;
       existing.envKey = ENV_KEY;
     } else {
-      entries.push({ id: model, name: "bailian-cli", baseUrl, envKey: ENV_KEY });
+      entries.push({
+        id: model,
+        name: "bailian-cli",
+        baseUrl,
+        envKey: ENV_KEY,
+      });
     }
     providers[protocol] = entries;
     settings.modelProviders = providers;
 
-    // security.auth — select the protocol and carry the OpenAI-compatible creds.
+    // security.auth — select the protocol only. Credentials live in env (via
+    // each provider entry's envKey); writing apiKey/baseUrl here is not part of
+    // the v3 schema.
     const security = (settings.security ?? {}) as Record<string, unknown>;
-    security.auth = { selectedType: protocol, apiKey, baseUrl };
+    security.auth = { selectedType: protocol };
     settings.security = security;
 
-    // model — active model, disambiguated by baseUrl.
-    settings.model = { name: model, baseUrl };
+    // model — active model id, resolved inside modelProviders[protocol].
+    settings.model = { name: model };
 
     writeJsonAtomic(settingsPath, settings);