feat: add modelProviders in settings to support custom model switching

packages/cli/src/config/config.ts

@@ -29,6 +29,7 @@ import {
 } from '@qwen-code/qwen-code-core';
 import { extensionsCommand } from '../commands/extensions.js';
 import type { Settings } from './settings.js';
+import { getModelProvidersConfigFromSettings } from './settings.js';
 import yargs, { type Argv } from 'yargs';
 import { hideBin } from 'yargs/helpers';
 import * as fs from 'node:fs';
@@ -864,11 +865,16 @@ export async function loadCliConfig(
     );
   }
 
-  const resolvedModel =
-    argv.model ||
-    process.env['OPENAI_MODEL'] ||
-    process.env['QWEN_MODEL'] ||
-    settings.model?.name;
+  let resolvedModel: string | undefined;
+
+  if (argv.model) {
+    resolvedModel = argv.model;
+  } else {
+    resolvedModel =
+      process.env['OPENAI_MODEL'] ||
+      process.env['QWEN_MODEL'] ||
+      settings.model?.name;
+  }
 
   const sandboxConfig = await loadSandboxConfig(settings, argv);
   const screenReader =
@@ -902,6 +908,8 @@ export async function loadCliConfig(
     }
   }
 
+  const modelProvidersConfig = getModelProvidersConfigFromSettings(settings);
+
   return new Config({
     sessionId,
     sessionData,
@@ -960,6 +968,7 @@ export async function loadCliConfig(
     inputFormat,
     outputFormat,
     includePartialMessages,
+    modelProvidersConfig,
     generationConfig: {
       ...(settings.model?.generationConfig || {}),
       model: resolvedModel,

packages/cli/src/config/settings.ts

@@ -14,6 +14,11 @@ import {
   QWEN_DIR,
   getErrorMessage,
   Storage,
+  type AuthType,
+  type ProviderModelConfig as ModelConfig,
+  type ModelProvidersConfig,
+  type ModelCapabilities,
+  type ModelGenerationConfig,
 } from '@qwen-code/qwen-code-core';
 import stripJsonComments from 'strip-json-comments';
 import { DefaultLight } from '../ui/themes/default-light.js';
@@ -47,7 +52,14 @@ function getMergeStrategyForPath(path: string[]): MergeStrategy | undefined {
   return current?.mergeStrategy;
 }
 
-export type { Settings, MemoryImportFormat };
+export type {
+  Settings,
+  MemoryImportFormat,
+  ModelConfig,
+  ModelProvidersConfig,
+  ModelCapabilities,
+  ModelGenerationConfig,
+};
 
 export const SETTINGS_DIRECTORY_NAME = '.qwen';
 export const USER_SETTINGS_PATH = Storage.getGlobalSettingsPath();
@@ -862,3 +874,31 @@ export function saveSettings(settingsFile: SettingsFile): void {
     throw error;
   }
 }
+
+/**
+ * Get models configuration from settings, grouped by authType.
+ * Returns the models config from the merged settings without mutating files.
+ *
+ * @param settings - The merged settings object
+ * @returns ModelProvidersConfig object (keyed by authType) or empty object if not configured
+ */
+export function getModelProvidersConfigFromSettings(
+  settings: Settings,
+): ModelProvidersConfig {
+  return (settings.modelProviders as ModelProvidersConfig) || {};
+}
+
+/**
+ * Get models for a specific authType from settings.
+ *
+ * @param settings - The merged settings object
+ * @param authType - The authType to get models for
+ * @returns Array of ModelConfig for the authType, or empty array if not configured
+ */
+export function getModelsForAuthType(
+  settings: Settings,
+  authType: string,
+): ModelConfig[] {
+  const modelProvidersConfig = getModelProvidersConfigFromSettings(settings);
+  return modelProvidersConfig[authType as AuthType] || [];
+}

packages/cli/src/config/settingsSchema.ts

@@ -10,6 +10,7 @@ import type {
   TelemetrySettings,
   AuthType,
   ChatCompressionSettings,
+  ModelProvidersConfig,
 } from '@qwen-code/qwen-code-core';
 import {
   ApprovalMode,
@@ -102,6 +103,19 @@ const SETTINGS_SCHEMA = {
     mergeStrategy: MergeStrategy.SHALLOW_MERGE,
   },
 
+  // Model providers configuration grouped by authType
+  modelProviders: {
+    type: 'object',
+    label: 'Model Providers',
+    category: 'Model',
+    requiresRestart: false,
+    default: {} as ModelProvidersConfig,
+    description:
+      'Model providers configuration grouped by authType. Each authType contains an array of model configurations.',
+    showInDialog: false,
+    mergeStrategy: MergeStrategy.SHALLOW_MERGE,
+  },
+
   general: {
     type: 'object',
     label: 'General',

packages/cli/src/ui/commands/modelCommand.ts

@@ -52,7 +52,7 @@ export const modelCommand: SlashCommand = {
       };
     }
 
-    const availableModels = getAvailableModelsForAuthType(authType);
+    const availableModels = getAvailableModelsForAuthType(authType, config);
 
     if (availableModels.length === 0) {
       return {

packages/cli/src/ui/components/ModelDialog.test.tsx

@@ -40,7 +40,8 @@ const renderComponent = (
     ? ({
         // --- Functions used by ModelDialog ---
         getModel: vi.fn(() => MAINLINE_CODER),
-        setModel: vi.fn(),
+        setModel: vi.fn().mockResolvedValue(undefined),
+        switchModel: vi.fn().mockResolvedValue(undefined),
         getAuthType: vi.fn(() => 'qwen-oauth'),
 
         // --- Functions used by ClearcutLogger ---
@@ -139,16 +140,19 @@ describe('<ModelDialog />', () => {
     expect(mockedSelect).toHaveBeenCalledTimes(1);
   });
 
-  it('calls config.setModel and onClose when DescriptiveRadioButtonSelect.onSelect is triggered', () => {
+  it('calls config.switchModel and onClose when DescriptiveRadioButtonSelect.onSelect is triggered', async () => {
     const { props, mockConfig } = renderComponent({}, {}); // Pass empty object for contextValue
 
     const childOnSelect = mockedSelect.mock.calls[0][0].onSelect;
     expect(childOnSelect).toBeDefined();
 
-    childOnSelect(MAINLINE_CODER);
+    await childOnSelect(MAINLINE_CODER);
 
-    // Assert against the default mock provided by renderComponent
-    expect(mockConfig?.setModel).toHaveBeenCalledWith(MAINLINE_CODER);
+    // Assert that switchModel is called with the model and metadata
+    expect(mockConfig?.switchModel).toHaveBeenCalledWith(MAINLINE_CODER, {
+      reason: 'user_manual',
+      context: 'Model switched via /model dialog',
+    });
     expect(props.onClose).toHaveBeenCalledTimes(1);
   });
 

packages/cli/src/ui/components/ModelDialog.tsx

@@ -29,13 +29,11 @@ interface ModelDialogProps {
 export function ModelDialog({ onClose }: ModelDialogProps): React.JSX.Element {
   const config = useContext(ConfigContext);
 
-  // Get auth type from config, default to QWEN_OAUTH if not available
   const authType = config?.getAuthType() ?? AuthType.QWEN_OAUTH;
 
-  // Get available models based on auth type
   const availableModels = useMemo(
-    () => getAvailableModelsForAuthType(authType),
-    [authType],
+    () => getAvailableModelsForAuthType(authType, config ?? undefined),
+    [authType, config],
   );
 
   const MODEL_OPTIONS = useMemo(
@@ -49,7 +47,6 @@ export function ModelDialog({ onClose }: ModelDialogProps): React.JSX.Element {
     [availableModels],
   );
 
-  // Determine the Preferred Model (read once when the dialog opens).
   const preferredModel = config?.getModel() || MAINLINE_CODER;
 
   useKeypress(
@@ -61,17 +58,18 @@ export function ModelDialog({ onClose }: ModelDialogProps): React.JSX.Element {
     { isActive: true },
   );
 
-  // Calculate the initial index based on the preferred model.
   const initialIndex = useMemo(
     () => MODEL_OPTIONS.findIndex((option) => option.value === preferredModel),
     [MODEL_OPTIONS, preferredModel],
   );
 
-  // Handle selection internally (Autonomous Dialog).
   const handleSelect = useCallback(
-    (model: string) => {
+    async (model: string) => {
       if (config) {
-        config.setModel(model);
+        await config.switchModel(model, {
+          reason: 'user_manual',
+          context: 'Model switched via /model dialog',
+        });
         const event = new ModelSlashCommandEvent(model);
         logModelSlashCommand(config, event);
       }

packages/cli/src/ui/models/availableModels.test.ts

@@ -0,0 +1,203 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import {
+  getAvailableModelsForAuthType,
+  getFilteredQwenModels,
+  getOpenAIAvailableModelFromEnv,
+  isVisionModel,
+  getDefaultVisionModel,
+  AVAILABLE_MODELS_QWEN,
+  MAINLINE_VLM,
+  MAINLINE_CODER,
+} from './availableModels.js';
+import { AuthType, type Config } from '@qwen-code/qwen-code-core';
+
+describe('availableModels', () => {
+  describe('AVAILABLE_MODELS_QWEN', () => {
+    it('should include coder model', () => {
+      const coderModel = AVAILABLE_MODELS_QWEN.find(
+        (m) => m.id === MAINLINE_CODER,
+      );
+      expect(coderModel).toBeDefined();
+      expect(coderModel?.isVision).toBeFalsy();
+    });
+
+    it('should include vision model', () => {
+      const visionModel = AVAILABLE_MODELS_QWEN.find(
+        (m) => m.id === MAINLINE_VLM,
+      );
+      expect(visionModel).toBeDefined();
+      expect(visionModel?.isVision).toBe(true);
+    });
+  });
+
+  describe('getFilteredQwenModels', () => {
+    it('should return all models when vision preview is enabled', () => {
+      const models = getFilteredQwenModels(true);
+      expect(models.length).toBe(AVAILABLE_MODELS_QWEN.length);
+    });
+
+    it('should filter out vision models when preview is disabled', () => {
+      const models = getFilteredQwenModels(false);
+      expect(models.every((m) => !m.isVision)).toBe(true);
+    });
+  });
+
+  describe('getOpenAIAvailableModelFromEnv', () => {
+    const originalEnv = process.env;
+
+    beforeEach(() => {
+      process.env = { ...originalEnv };
+    });
+
+    afterEach(() => {
+      process.env = originalEnv;
+    });
+
+    it('should return null when OPENAI_MODEL is not set', () => {
+      delete process.env['OPENAI_MODEL'];
+      expect(getOpenAIAvailableModelFromEnv()).toBeNull();
+    });
+
+    it('should return model from OPENAI_MODEL env var', () => {
+      process.env['OPENAI_MODEL'] = 'gpt-4-turbo';
+      const model = getOpenAIAvailableModelFromEnv();
+      expect(model?.id).toBe('gpt-4-turbo');
+      expect(model?.label).toBe('gpt-4-turbo');
+    });
+
+    it('should trim whitespace from env var', () => {
+      process.env['OPENAI_MODEL'] = '  gpt-4  ';
+      const model = getOpenAIAvailableModelFromEnv();
+      expect(model?.id).toBe('gpt-4');
+    });
+  });
+
+  describe('getAvailableModelsForAuthType', () => {
+    const originalEnv = process.env;
+
+    beforeEach(() => {
+      process.env = { ...originalEnv };
+    });
+
+    afterEach(() => {
+      process.env = originalEnv;
+    });
+
+    it('should return hard-coded qwen models for qwen-oauth', () => {
+      const models = getAvailableModelsForAuthType(AuthType.QWEN_OAUTH);
+      expect(models).toEqual(AVAILABLE_MODELS_QWEN);
+    });
+
+    it('should return hard-coded qwen models even when config is provided', () => {
+      const mockConfig = {
+        getAvailableModels: vi
+          .fn()
+          .mockReturnValue([
+            { id: 'custom', label: 'Custom', authType: AuthType.QWEN_OAUTH },
+          ]),
+      } as unknown as Config;
+
+      const models = getAvailableModelsForAuthType(
+        AuthType.QWEN_OAUTH,
+        mockConfig,
+      );
+      expect(models).toEqual(AVAILABLE_MODELS_QWEN);
+    });
+
+    it('should use config.getAvailableModels for openai authType when available', () => {
+      const mockModels = [
+        {
+          id: 'gpt-4',
+          label: 'GPT-4',
+          description: 'Test',
+          authType: AuthType.USE_OPENAI,
+          isVision: false,
+        },
+      ];
+      const mockConfig = {
+        getAvailableModels: vi.fn().mockReturnValue(mockModels),
+      } as unknown as Config;
+
+      const models = getAvailableModelsForAuthType(
+        AuthType.USE_OPENAI,
+        mockConfig,
+      );
+
+      expect(mockConfig.getAvailableModels).toHaveBeenCalled();
+      expect(models[0].id).toBe('gpt-4');
+    });
+
+    it('should fallback to env var for openai when config returns empty', () => {
+      process.env['OPENAI_MODEL'] = 'fallback-model';
+      const mockConfig = {
+        getAvailableModels: vi.fn().mockReturnValue([]),
+      } as unknown as Config;
+
+      const models = getAvailableModelsForAuthType(
+        AuthType.USE_OPENAI,
+        mockConfig,
+      );
+
+      expect(models[0].id).toBe('fallback-model');
+    });
+
+    it('should fallback to env var for openai when config throws', () => {
+      process.env['OPENAI_MODEL'] = 'fallback-model';
+      const mockConfig = {
+        getAvailableModels: vi.fn().mockImplementation(() => {
+          throw new Error('Registry not initialized');
+        }),
+      } as unknown as Config;
+
+      const models = getAvailableModelsForAuthType(
+        AuthType.USE_OPENAI,
+        mockConfig,
+      );
+
+      expect(models[0].id).toBe('fallback-model');
+    });
+
+    it('should return env model for openai without config', () => {
+      process.env['OPENAI_MODEL'] = 'gpt-4-turbo';
+      const models = getAvailableModelsForAuthType(AuthType.USE_OPENAI);
+      expect(models[0].id).toBe('gpt-4-turbo');
+    });
+
+    it('should return empty array for openai without config or env', () => {
+      delete process.env['OPENAI_MODEL'];
+      const models = getAvailableModelsForAuthType(AuthType.USE_OPENAI);
+      expect(models).toEqual([]);
+    });
+
+    it('should return empty array for other auth types', () => {
+      const models = getAvailableModelsForAuthType(AuthType.USE_GEMINI);
+      expect(models).toEqual([]);
+    });
+  });
+
+  describe('isVisionModel', () => {
+    it('should return true for vision model', () => {
+      expect(isVisionModel(MAINLINE_VLM)).toBe(true);
+    });
+
+    it('should return false for non-vision model', () => {
+      expect(isVisionModel(MAINLINE_CODER)).toBe(false);
+    });
+
+    it('should return false for unknown model', () => {
+      expect(isVisionModel('unknown-model')).toBe(false);
+    });
+  });
+
+  describe('getDefaultVisionModel', () => {
+    it('should return the vision model ID', () => {
+      expect(getDefaultVisionModel()).toBe(MAINLINE_VLM);
+    });
+  });
+});

packages/cli/src/ui/models/availableModels.ts

@@ -4,7 +4,12 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { AuthType, DEFAULT_QWEN_MODEL } from '@qwen-code/qwen-code-core';
+import {
+  AuthType,
+  DEFAULT_QWEN_MODEL,
+  type Config,
+  type AvailableModel as CoreAvailableModel,
+} from '@qwen-code/qwen-code-core';
 import { t } from '../../i18n/index.js';
 
 export type AvailableModel = {
@@ -60,24 +65,56 @@ export function getOpenAIAvailableModelFromEnv(): AvailableModel | null {
   return id ? { id, label: id } : null;
 }
 
-export function getAvailableModelsForAuthType(
-  authType: AuthType,
-): AvailableModel[] {
-  switch (authType) {
-    case AuthType.QWEN_OAUTH:
-      return AVAILABLE_MODELS_QWEN;
-    case AuthType.USE_OPENAI: {
-      const openAIModel = getOpenAIAvailableModelFromEnv();
-      return openAIModel ? [openAIModel] : [];
-    }
-    default:
-      // For other auth types, return empty array for now
-      // This can be expanded later according to the design doc
-      return [];
-  }
+/**
+ * Convert core AvailableModel to CLI AvailableModel format
+ */
+function convertCoreModelToCliModel(
+  coreModel: CoreAvailableModel,
+): AvailableModel {
+  return {
+    id: coreModel.id,
+    label: coreModel.label,
+    description: coreModel.description,
+    isVision: coreModel.isVision ?? coreModel.capabilities?.vision ?? false,
+  };
 }
 
 /**
+ * Get available models for the given authType.
+ *
+ * If a Config object is provided, uses the model registry to get models.
+ * For qwen-oauth, always returns the hard-coded models.
+ * For openai authType, falls back to environment variable if no config provided.
+ */
+export function getAvailableModelsForAuthType(
+  authType: AuthType,
+  config?: Config,
+): AvailableModel[] {
+  // For qwen-oauth, always use hard-coded models, this aligns with the API gateway.
+  if (authType === AuthType.QWEN_OAUTH) {
+    return AVAILABLE_MODELS_QWEN;
+  }
+
+  if (config) {
+    try {
+      const models = config.getAvailableModels();
+      if (models.length > 0) {
+        return models.map(convertCoreModelToCliModel);
+      }
+    } catch (error) {
+      console.error('Failed to get models from model registry', error);
+    }
+  }
+
+  if (authType === AuthType.USE_OPENAI) {
+    const openAIModel = getOpenAIAvailableModelFromEnv();
+    return openAIModel ? [openAIModel] : [];
+  }
+
+  // For other auth types, return empty array
+  return [];
+}
+
 /**
  * Hard code the default vision model as a string literal,
  * until our coding model supports multimodal.