feat(qwen-code): add warnings for environment variable conflicts and enhance model entry handling

- Introduced warnings for cases where the environment variable overrides the settings file.
- Updated model entry handling to prevent overwriting existing entries with the same ID.
- Enhanced the display name for bailian-cli model entries to include the model name.
- Updated WriteSummary interface to include warnings for non-fatal issues.

Author: qcq01083097

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

@@ -66,6 +66,9 @@ export default defineCommand({
       emitBare(`${agentDef.label} configured successfully.`);
       for (const path of summary.paths) emitBare(`  Written: ${path}`);
       emitBare(`  ${summary.nextStep}`);
+      for (const warning of summary.warnings ?? []) {
+        process.stderr.write(`Warning: ${warning}\n`);
+      }
     }
   },
 });

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

@@ -4,58 +4,106 @@ import { backup, readJson, writeJsonAtomic, isAnthropicEndpoint, type AgentDef }
 
 const ENV_KEY = "BAILIAN_CLI_API_KEY";
 
+function displayName(model: string): string {
+  return `${model} (bailian-cli)`;
+}
+
+/** Entries we previously wrote, or still own via envKey. */
+function isBailianCliEntry(entry: Record<string, unknown>): boolean {
+  return entry.envKey === ENV_KEY || entry.name === "bailian-cli";
+}
+
 /**
  * Qwen Code keys `modelProviders` and `security.auth.selectedType` by the SDK
  * protocol (an AuthType string), not by a free-form provider id — the runtime
- * resolver indexes credentials/defaults by protocol. The `bailian-cli` brand
- * therefore lives in the model entry `name` and the env var name.
+ * resolver indexes credentials/defaults by protocol. Ownership is tracked via
+ * `envKey` (`BAILIAN_CLI_API_KEY`) and a display `name` suffix `(bailian-cli)`.
+ *
+ * Qwen Code does not support duplicate model `id`s (only the first loads), so
+ * we must never overwrite a pre-existing Token Plan / third-party entry that
+ * shares the same id.
  */
 export default {
   label: "Qwen Code",
   write({ baseUrl, apiKey, model }) {
     const settingsPath = join(homedir(), ".qwen", "settings.json");
     const protocol = isAnthropicEndpoint(baseUrl) ? "anthropic" : "openai";
+    const warnings: string[] = [];
 
     backup(settingsPath);
     const settings = readJson(settingsPath);
 
     // env — API key read by the provider entry's envKey.
+    // Qwen Code treats settings.json `env` as lowest priority; a process/shell
+    // value for the same key wins and can make the first launch fail.
     const env = (settings.env ?? {}) as Record<string, string>;
     env[ENV_KEY] = apiKey;
     settings.env = env;
 
-    // modelProviders[<protocol>] — upsert the bailian-cli model entry.
+    const processEnvValue = process.env[ENV_KEY];
+    if (processEnvValue !== undefined && processEnvValue !== apiKey) {
+      warnings.push(
+        `Shell/environment ${ENV_KEY} is set and overrides settings.json. ` +
+          `Unset it (e.g. \`unset ${ENV_KEY}\`) so the key written here takes effect.`,
+      );
+    }
+
+    // modelProviders[<protocol>] — upsert only bailian-cli-owned entries.
     const providers = (settings.modelProviders ?? {}) as Record<
       string,
       Array<Record<string, unknown>>
     >;
     const entries = (providers[protocol] ?? []) as Array<Record<string, unknown>>;
-    const existing = entries.find(
-      (entry) => entry.id === model && (entry.baseUrl ?? "") === baseUrl,
-    );
-    if (existing) {
-      existing.name = "bailian-cli";
-      existing.baseUrl = baseUrl;
-      existing.envKey = ENV_KEY;
+    const owned = entries.find((entry) => isBailianCliEntry(entry) && entry.id === model);
+    const conflicting = entries.find((entry) => !isBailianCliEntry(entry) && entry.id === model);
+
+    if (owned) {
+      owned.name = displayName(model);
+      owned.baseUrl = baseUrl;
+      owned.envKey = ENV_KEY;
+    } else if (conflicting) {
+      const existingName =
+        typeof conflicting.name === "string" && conflicting.name.length > 0
+          ? conflicting.name
+          : String(conflicting.id);
+      warnings.push(
+        `Model id "${model}" already exists as "${existingName}"; left unchanged ` +
+          `(Qwen Code loads only the first entry per id). Remove or rename that ` +
+          `entry if you want bailian-cli to own this model.`,
+      );
     } else {
-      entries.push({ id: model, name: "bailian-cli", baseUrl, envKey: ENV_KEY });
+      entries.push({
+        id: model,
+        name: displayName(model),
+        baseUrl,
+        envKey: ENV_KEY,
+      });
     }
     providers[protocol] = entries;
     settings.modelProviders = providers;
 
-    // security.auth — select the protocol and carry the OpenAI-compatible creds.
+    // security.auth — select protocol only. Prefer modelProviders + envKey for
+    // credentials; apiKey/baseUrl on auth are deprecated in Qwen Code.
     const security = (settings.security ?? {}) as Record<string, unknown>;
-    security.auth = { selectedType: protocol, apiKey, baseUrl };
+    const previousAuth =
+      security.auth && typeof security.auth === "object"
+        ? (security.auth as Record<string, unknown>)
+        : {};
+    security.auth = { ...previousAuth, selectedType: protocol };
+    // Drop deprecated inline creds so they cannot disagree with envKey lookup.
+    delete (security.auth as Record<string, unknown>).apiKey;
+    delete (security.auth as Record<string, unknown>).baseUrl;
     settings.security = security;
 
-    // model — active model, disambiguated by baseUrl.
+    // model — active model id (disambiguated by baseUrl when supported).
     settings.model = { name: model, baseUrl };
 
     writeJsonAtomic(settingsPath, settings);
 
     return {
       paths: [settingsPath],
       nextStep: "Run `qwen` to start using Qwen Code with DashScope.",
+      warnings: warnings.length > 0 ? warnings : undefined,
     };
   },
 } satisfies AgentDef;

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

@@ -12,6 +12,8 @@ export interface WriteParams {
 export interface WriteSummary {
   paths: string[];
   nextStep: string;
+  /** Non-fatal issues the command should surface to the user. */
+  warnings?: string[];
 }
 
 /** An agent configuration writer: a human label plus a `write` that applies it. */

packages/commands/tests/config-agent-writers.test.ts

@@ -75,14 +75,14 @@ describe("config agent writers", () => {
     const settings = readJsonAt(".qwen", "settings.json");
     const security = settings.security as { auth: Record<string, string> };
     expect(security.auth.selectedType).toBe("openai");
-    expect(security.auth.apiKey).toBe("sk-q");
-    expect(security.auth.baseUrl).toBe(OAI_URL);
+    expect(security.auth.apiKey).toBeUndefined();
+    expect(security.auth.baseUrl).toBeUndefined();
     expect((settings.env as Record<string, string>).BAILIAN_CLI_API_KEY).toBe("sk-q");
     expect((settings.model as Record<string, string>).name).toBe("qwen3-coder-plus");
     const providers = settings.modelProviders as Record<string, Array<Record<string, unknown>>>;
     expect(providers.openai[0]).toMatchObject({
       id: "qwen3-coder-plus",
-      name: "bailian-cli",
+      name: "qwen3-coder-plus (bailian-cli)",
       baseUrl: OAI_URL,
       envKey: "BAILIAN_CLI_API_KEY",
     });
@@ -99,12 +99,76 @@ describe("config agent writers", () => {
     expect(providers.openai).toBeUndefined();
   });
 
-  test("qwen-code 对相同 id+baseUrl 的 provider 项做 upsert 而非追加", () => {
+  test("qwen-code 对自有 provider 项按 id upsert 而非追加", () => {
     qwenCode.write({ baseUrl: OAI_URL, apiKey: "sk-1", model: "qwen3-coder-plus" });
     qwenCode.write({ baseUrl: OAI_URL, apiKey: "sk-2", model: "qwen3-coder-plus" });
     const settings = readJsonAt(".qwen", "settings.json");
     const openaiEntries = (settings.modelProviders as Record<string, unknown[]>).openai;
     expect(openaiEntries).toHaveLength(1);
+    expect((settings.env as Record<string, string>).BAILIAN_CLI_API_KEY).toBe("sk-2");
+  });
+
+  test("qwen-code 不劫持已有 Token Plan 同 id 条目的 name/envKey", () => {
+    mkdirSync(join(home, ".qwen"), { recursive: true });
+    writeFileSync(
+      join(home, ".qwen", "settings.json"),
+      JSON.stringify({
+        env: { BAILIAN_TOKEN_PLAN_API_KEY: "sk-token-plan" },
+        modelProviders: {
+          openai: [
+            {
+              id: "qwen3.8-max-preview",
+              name: "[Token Plan 个人版] qwen3.8-max-preview",
+              baseUrl: "https://token-plan.cn-beijing.maas.aliyuncs.com/compatible-mode/v1",
+              envKey: "BAILIAN_TOKEN_PLAN_API_KEY",
+              generationConfig: { extra_body: { enable_thinking: true } },
+            },
+          ],
+        },
+      }),
+    );
+
+    const tokenPlanUrl = "https://token-plan.cn-beijing.maas.aliyuncs.com/compatible-mode/v1";
+    const summary = qwenCode.write({
+      baseUrl: tokenPlanUrl,
+      apiKey: "sk-bailian",
+      model: "qwen3.8-max-preview",
+    });
+
+    const settings = readJsonAt(".qwen", "settings.json");
+    const openaiEntries = (
+      settings.modelProviders as Record<string, Array<Record<string, unknown>>>
+    ).openai;
+    expect(openaiEntries).toHaveLength(1);
+    expect(openaiEntries[0]).toMatchObject({
+      id: "qwen3.8-max-preview",
+      name: "[Token Plan 个人版] qwen3.8-max-preview",
+      envKey: "BAILIAN_TOKEN_PLAN_API_KEY",
+      generationConfig: { extra_body: { enable_thinking: true } },
+    });
+    expect((settings.env as Record<string, string>).BAILIAN_TOKEN_PLAN_API_KEY).toBe(
+      "sk-token-plan",
+    );
+    expect((settings.env as Record<string, string>).BAILIAN_CLI_API_KEY).toBe("sk-bailian");
+    expect(summary.warnings?.some((warning) => warning.includes("already exists"))).toBe(true);
+  });
+
+  test("qwen-code 在进程环境变量覆盖 settings.env 时给出警告", () => {
+    const previous = process.env.BAILIAN_CLI_API_KEY;
+    process.env.BAILIAN_CLI_API_KEY = "sk-from-shell";
+    try {
+      const summary = qwenCode.write({
+        baseUrl: OAI_URL,
+        apiKey: "sk-from-settings",
+        model: "qwen3-coder-plus",
+      });
+      expect(summary.warnings?.some((warning) => warning.includes("overrides settings.json"))).toBe(
+        true,
+      );
+    } finally {
+      if (previous === undefined) delete process.env.BAILIAN_CLI_API_KEY;
+      else process.env.BAILIAN_CLI_API_KEY = previous;
+    }
   });
 
   test("opencode 按端点选 npm，含 setCacheKey，合并保留其它 provider", () => {