尝试provider（api）指令切换模型类型

src/commands.ts

@@ -150,6 +150,7 @@ import sandboxToggle from './commands/sandbox-toggle/index.js'
 import chrome from './commands/chrome/index.js'
 import stickers from './commands/stickers/index.js'
 import advisor from './commands/advisor.js'
+import provider from './commands/provider.js'
 import { logError } from './utils/log.js'
 import { toError } from './utils/errors.js'
 import { logForDebugging } from './utils/debug.js'
@@ -258,6 +259,7 @@ export const INTERNAL_ONLY_COMMANDS = [
 const COMMANDS = memoize((): Command[] => [
   addDir,
   advisor,
+  provider,
   agents,
   branch,
   btw,

src/commands/provider.ts

@@ -0,0 +1,109 @@
+import type { Command } from '../commands.js'
+import type { LocalCommandCall } from '../types/command.js'
+import { getAPIProvider } from '../utils/model/providers.js'
+import { updateSettingsForSource } from '../utils/settings/settings.js'
+import { getSettings_DEPRECATED } from '../utils/settings/settings.js'
+import { applyConfigEnvironmentVariables } from '../utils/managedEnv.js'
+
+function getEnvVarForProvider(provider: string): string {
+  switch (provider) {
+    case 'bedrock':
+      return 'CLAUDE_CODE_USE_BEDROCK'
+    case 'vertex':
+      return 'CLAUDE_CODE_USE_VERTEX'
+    case 'foundry':
+      return 'CLAUDE_CODE_USE_FOUNDRY'
+    default:
+      throw new Error(`Unknown provider: ${provider}`)
+  }
+}
+
+// Get merged env: process.env + settings.env (from userSettings)
+function getMergedEnv(): Record<string, string> {
+  const settings = getSettings_DEPRECATED()
+  const merged = { ...process.env }
+  if (settings?.env) {
+    Object.assign(merged, settings.env)
+  }
+  return merged
+}
+
+const call: LocalCommandCall = async (args, context) => {
+  const arg = args.trim().toLowerCase()
+
+  // No argument: show current provider
+  if (!arg) {
+    const current = getAPIProvider()
+    return { type: 'text', value: `Current API provider: ${current}` }
+  }
+
+  // unset - clear settings, fallback to env vars
+  if (arg === 'unset') {
+    updateSettingsForSource('userSettings', { modelType: undefined })
+    // Also clear all provider-specific env vars to prevent conflicts
+    delete process.env.CLAUDE_CODE_USE_BEDROCK
+    delete process.env.CLAUDE_CODE_USE_VERTEX
+    delete process.env.CLAUDE_CODE_USE_FOUNDRY
+    delete process.env.CLAUDE_CODE_USE_OPENAI
+    return { type: 'text', value: 'API provider cleared (will use environment variables).' }
+  }
+
+  // Validate provider
+  const validProviders = ['anthropic', 'openai', 'bedrock', 'vertex', 'foundry']
+  if (!validProviders.includes(arg)) {
+    return { type: 'text', value: `Invalid provider: ${arg}\nValid: ${validProviders.join(', ')}` }
+  }
+
+  // Check env vars when switching to openai (including settings.env)
+  if (arg === 'openai') {
+    const mergedEnv = getMergedEnv()
+    const hasKey = !!mergedEnv.OPENAI_API_KEY
+    const hasUrl = !!mergedEnv.OPENAI_BASE_URL
+    if (!hasKey || !hasUrl) {
+      updateSettingsForSource('userSettings', { modelType: 'openai' })
+      const missing = []
+      if (!hasKey) missing.push('OPENAI_API_KEY')
+      if (!hasUrl) missing.push('OPENAI_BASE_URL')
+      return {
+        type: 'text',
+        value: `Switched to OpenAI provider.\nWarning: Missing env vars: ${missing.join(', ')}\nConfigure them via /login or set manually.`,
+      }
+    }
+  }
+
+  // Handle different provider types
+  // - 'anthropic' and 'openai' are stored in settings.json (persistent)
+  // - 'bedrock', 'vertex', 'foundry' are env-only (do NOT touch settings.json)
+  if (arg === 'anthropic' || arg === 'openai') {
+    // Clear any cloud provider env vars to avoid conflicts
+    delete process.env.CLAUDE_CODE_USE_BEDROCK
+    delete process.env.CLAUDE_CODE_USE_VERTEX
+    delete process.env.CLAUDE_CODE_USE_FOUNDRY
+    // Update settings.json
+    updateSettingsForSource('userSettings', { modelType: arg })
+    // Ensure settings.env gets applied to process.env
+    applyConfigEnvironmentVariables()
+    return { type: 'text', value: `API provider set to ${arg}.` }
+  } else {
+    // Cloud providers: set env vars only, do NOT touch settings.modelType
+    delete process.env.CLAUDE_CODE_USE_OPENAI
+    delete process.env.OPENAI_API_KEY
+    delete process.env.OPENAI_BASE_URL
+    process.env[getEnvVarForProvider(arg)] = '1'
+    // Do not modify settings.json - cloud providers controlled solely by env vars
+    applyConfigEnvironmentVariables()
+    return { type: 'text', value: `API provider set to ${arg} (via environment variable).` }
+  }
+}
+
+const provider = {
+  type: 'local',
+  name: 'provider',
+  description: 'Switch API provider (anthropic/openai/bedrock/vertex/foundry)',
+  aliases: ['api'],
+  argumentHint: '[anthropic|openai|bedrock|vertex|foundry|unset]',
+  supportsNonInteractive: true,
+  load: () => Promise.resolve({ call }),
+} satisfies Command
+
+export default provider

src/utils/model/__tests__/providers.test.ts

@@ -1,19 +1,57 @@
-import { describe, expect, test, beforeEach, afterEach } from "bun:test";
+import { describe, expect, test, beforeEach, afterEach, beforeAll, afterAll } from "bun:test";
 import { getAPIProvider, isFirstPartyAnthropicBaseUrl } from "../providers";
+import { readFileSync, writeFileSync } from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import { homedir } from "os";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+function getSettingsPath(): string {
+  return path.join(homedir(), ".claude", "settings.json");
+}
 
 describe("getAPIProvider", () => {
   const envKeys = [
     "CLAUDE_CODE_USE_BEDROCK",
     "CLAUDE_CODE_USE_VERTEX",
     "CLAUDE_CODE_USE_FOUNDRY",
+    "CLAUDE_CODE_USE_OPENAI",
   ] as const;
   const savedEnv: Record<string, string | undefined> = {};
+  let originalSettings: string = "";
+
+  beforeAll(() => {
+    // Backup and clear settings.json modelType
+    const settingsPath = getSettingsPath();
+    try {
+      originalSettings = readFileSync(settingsPath, "utf-8");
+      const parsed = JSON.parse(originalSettings);
+      delete parsed.modelType;
+      writeFileSync(settingsPath, JSON.stringify(parsed, null, 2) + "\n");
+    } catch (e) {
+      // If file doesn't exist or can't parse, ignore
+    }
+  });
+
+  afterAll(() => {
+    // Restore original settings.json
+    if (originalSettings) {
+      writeFileSync(getSettingsPath(), originalSettings);
+    }
+  });
 
   beforeEach(() => {
-    for (const key of envKeys) savedEnv[key] = process.env[key];
+    // Save and clear environment variables
+    for (const key of envKeys) {
+      savedEnv[key] = process.env[key];
+      delete process.env[key];
+    }
   });
 
   afterEach(() => {
+    // Restore environment variables
     for (const key of envKeys) {
       if (savedEnv[key] !== undefined) {
         process.env[key] = savedEnv[key];
@@ -24,9 +62,6 @@ describe("getAPIProvider", () => {
   });
 
   test('returns "firstParty" by default', () => {
-    delete process.env.CLAUDE_CODE_USE_BEDROCK;
-    delete process.env.CLAUDE_CODE_USE_VERTEX;
-    delete process.env.CLAUDE_CODE_USE_FOUNDRY;
     expect(getAPIProvider()).toBe("firstParty");
   });
 

src/utils/model/providers.ts

@@ -5,20 +5,20 @@ import { isEnvTruthy } from '../envUtils.js'
 export type APIProvider = 'firstParty' | 'bedrock' | 'vertex' | 'foundry' | 'openai'
 
 export function getAPIProvider(): APIProvider {
-  // 1. Check settings.json modelType field (highest priority)
+  // Cloud provider env vars have highest priority (they are explicit switches)
+  if (isEnvTruthy(process.env.CLAUDE_CODE_USE_BEDROCK)) return 'bedrock'
+  if (isEnvTruthy(process.env.CLAUDE_CODE_USE_VERTEX)) return 'vertex'
+  if (isEnvTruthy(process.env.CLAUDE_CODE_USE_FOUNDRY)) return 'foundry'
+
+  // Check settings.json modelType field
   const modelType = getInitialSettings().modelType
   if (modelType === 'openai') return 'openai'
 
-  // 2. Check environment variables (backward compatibility)
-  return isEnvTruthy(process.env.CLAUDE_CODE_USE_OPENAI)
-    ? 'openai'
-    : isEnvTruthy(process.env.CLAUDE_CODE_USE_BEDROCK)
-      ? 'bedrock'
-      : isEnvTruthy(process.env.CLAUDE_CODE_USE_VERTEX)
-        ? 'vertex'
-        : isEnvTruthy(process.env.CLAUDE_CODE_USE_FOUNDRY)
-          ? 'foundry'
-          : 'firstParty'
+  // Backward compatibility: check legacy OpenAI env var
+  if (isEnvTruthy(process.env.CLAUDE_CODE_USE_OPENAI)) return 'openai'
+
+  // Default: Anthropic first-party API
+  return 'firstParty'
 }
 
 export function getAPIProviderForStatsig(): AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS {