添加一个 provider 需要改 4 个地方：

1. src/shared/models/xxx.ts              - Model class (继承 AbstractAISDKModel)
2. src/shared/models/index.ts            - 在 400 行 switch 中加 case
3. src/renderer/.../xxx-setting-util.ts  - SettingUtil class
4. src/shared/defaults.ts                - 在 SystemProviders[] 加配置

问题：
- 同一个 provider 的信息分散在 4 个文件
- getModel() switch 语句 400 行，难以维护
- Model class 和 SettingUtil class 有重复逻辑（如 listModels）
- 添加/修改 provider 容易遗漏某个文件

添加一个 provider 只需 1 个文件：

src/shared/providers/
├── registry.ts              # 注册中心 + getModel() 实现
├── types.ts                 # ProviderDefinition 类型
├── definitions/             # Provider 定义（每个 1 文件，包含所有信息）
│   ├── openai.ts           # Model class + 配置 + 元数据
│   ├── claude.ts
│   ├── groq.ts
│   └── ...
└── index.ts                 # 导出

改变：
- 4 个文件 → 1 个 defineProvider() 定义
- getModel() 400 行 switch → ~10 行 registry lookup
- SettingUtil 合并到 provider 定义中
- SystemProviders 从 registry 生成

保留：
- AbstractAISDKModel 基类不变
- 每个 provider 独立的 Model class
- 继承 + 覆盖方法的扩展方式

// src/shared/providers/types.ts

import type { ModelInterface } from '../models/types'
import type { ModelProvider, ModelProviderType, ProviderModelInfo, ProviderSettings, SessionType } from '../types'
import type { ModelDependencies } from '../types/adapters'

export interface ProviderDefinition {
  // === 基本信息 (原 SystemProviders) ===
  id: ModelProvider
  name: string
  type: ModelProviderType
  
  urls?: {
    website?: string
    apiKey?: string
    docs?: string
    models?: string
  }
  
  defaultSettings?: ProviderSettings
  
  // === 创建 Model 实例（合并 modelClass + buildModelOptions）===
  // 直接调用 new XxxModel(...)，TypeScript 自动检查构造函数参数类型
  createModel: (ctx: CreateModelContext) => ModelInterface
  
  // === SettingUtil 功能 (原 model-setting-utils/xxx.ts) ===
  getDisplayName?: (modelId: string, sessionType: SessionType, providerSettings?: ProviderSettings) => string
  
  // listModels 已在 Model class 中，不需要重复
}

export interface CreateModelContext {
  sessionSettings: SessionSettings
  globalSettings: Settings
  providerSettings: ProviderSettings
  providerBaseInfo: ProviderBaseInfo
  model: ProviderModelInfo
  dependencies: ModelDependencies
}

// src/shared/providers/definitions/groq.ts

import { ModelProviderEnum, ModelProviderType } from '../../types'
import Groq from './models/groq'  // Model class 保持不变

export default defineProvider({
  id: ModelProviderEnum.Groq,
  name: 'Groq',
  type: ModelProviderType.OpenAI,
  
  urls: {
    website: 'https://groq.com/',
  },
  
  defaultSettings: {
    apiHost: 'https://api.groq.com/openai',
    models: [
      { modelId: 'llama-3.3-70b-versatile', contextWindow: 131072, capabilities: ['tool_use'] },
    ],
  },
  
  // 直接创建 Model 实例，TypeScript 检查构造函数参数
  createModel: (ctx) => new Groq({
    apiKey: ctx.providerSettings.apiKey || '',
    model: ctx.model,
    temperature: ctx.sessionSettings.temperature,
    topP: ctx.sessionSettings.topP,
    maxOutputTokens: ctx.sessionSettings.maxTokens,
    stream: ctx.sessionSettings.stream,
  }, ctx.dependencies),
  
  getDisplayName: (modelId) => `Groq API (${modelId})`,
})

// src/shared/providers/definitions/openai.ts

import { ModelProviderEnum, ModelProviderType } from '../../types'
import OpenAI from './models/openai'

export default defineProvider({
  id: ModelProviderEnum.OpenAI,
  name: 'OpenAI',
  type: ModelProviderType.OpenAI,
  
  urls: {
    website: 'https://openai.com',
  },
  
  defaultSettings: {
    apiHost: 'https://api.openai.com',
    models: [
      { modelId: 'gpt-4o', capabilities: ['vision', 'tool_use'], contextWindow: 128000 },
      { modelId: 'o3-mini', capabilities: ['vision', 'tool_use', 'reasoning'], contextWindow: 200000 },
      { modelId: 'text-embedding-3-small', type: 'embedding' },
    ],
  },
  
  // 直接创建 Model 实例，TypeScript 检查构造函数参数
  createModel: (ctx) => new OpenAI({
    apiKey: ctx.providerSettings.apiKey || '',
    apiHost: ctx.providerSettings.apiHost || 'https://api.openai.com',
    model: ctx.model,
    dalleStyle: ctx.sessionSettings.dalleStyle || 'vivid',
    temperature: ctx.sessionSettings.temperature,
    topP: ctx.sessionSettings.topP,
    maxOutputTokens: ctx.sessionSettings.maxTokens,
    injectDefaultMetadata: ctx.globalSettings.injectDefaultMetadata,
    useProxy: false,
    stream: ctx.sessionSettings.stream,
  }, ctx.dependencies),
  
  getDisplayName: (modelId, sessionType, providerSettings) => {
    if (sessionType === 'picture') {
      return 'OpenAI API (DALL-E-3)'
    }
    const nickname = providerSettings?.models?.find(m => m.modelId === modelId)?.nickname
    return `OpenAI API (${nickname || modelId})`
  },
})

// src/shared/providers/registry.ts

const providers = new Map<string, ProviderDefinition>()

export function defineProvider<T>(definition: ProviderDefinition<T>): ProviderDefinition<T> {
  providers.set(definition.id, definition)
  return definition
}

export function getProviderDefinition(id: string): ProviderDefinition | undefined {
  return providers.get(id)
}

export function getAllProviders(): ProviderDefinition[] {
  return Array.from(providers.values())
}

// 替代原来的 SystemProviders
export function getSystemProviders(): ProviderBaseInfo[] {
  return getAllProviders().map(p => ({
    id: p.id,
    name: p.name,
    type: p.type,
    urls: p.urls,
    defaultSettings: p.defaultSettings,
  }))
}

// src/shared/providers/index.ts

export function getModel(
  settings: SessionSettings,
  globalSettings: Settings,
  config: Config,
  dependencies: ModelDependencies
): ModelInterface {
  const provider = settings.provider
  if (!provider) {
    throw new Error('Model provider must not be empty.')
  }

  // 获取 provider 定义
  const definition = getProviderDefinition(provider)
  if (!definition) {
    // 处理 custom provider（见 US-013）
    return createCustomProviderModel(settings, globalSettings, config, dependencies)
  }

  // 构建 context 并创建 model
  const { providerSettings, model } = resolveProviderContext(settings, globalSettings, definition)
  
  return definition.createModel({
    sessionSettings: settings,
    globalSettings,
    providerSettings,
    providerBaseInfo: definition,
    model,
    dependencies,
  })
}

src/shared/
├── providers/
│   ├── index.ts                 # 导出 getModel, registry functions
│   ├── registry.ts              # defineProvider, getProviderDefinition
│   ├── types.ts                 # ProviderDefinition 类型
│   ├── utils.ts                 # resolveProviderContext, createCustomProviderModel
│   └── definitions/
│       ├── index.ts             # 自动导入所有定义
│       ├── openai.ts
│       ├── claude.ts
│       ├── gemini.ts
│       ├── deepseek.ts
│       ├── azure.ts
│       ├── chatboxai.ts
│       ├── ollama.ts
│       ├── groq.ts
│       ├── perplexity.ts
│       ├── xai.ts
│       ├── mistral-ai.ts
│       ├── siliconflow.ts
│       ├── volcengine.ts
│       ├── chatglm.ts
│       ├── lmstudio.ts
│       ├── openrouter.ts
│       ├── openai-responses.ts
│       └── models/              # Model classes (从 src/shared/models/ 移动)
│           ├── abstract-ai-sdk.ts
│           ├── openai.ts
│           ├── claude.ts
│           └── ...
│
├── models/                      # 保留，逐步迁移到 providers/definitions/models/
│   └── index.ts                 # 改为从 providers 重新导出（兼容）
│
└── defaults.ts                  # SystemProviders 改为从 registry 获取

src/shared/providers/
├── index.ts              # getModel(), getProviderSettings()
├── registry.ts           # defineProvider(), getProviderDefinition(), getAllProviders()
├── types.ts              # ProviderDefinition, CreateModelConfig
├── utils.ts              # createCustomProviderModel()
└── definitions/
    ├── groq.ts, openai.ts, claude.ts, ...  # 17 provider definitions
    └── models/
        ├── groq.ts, openai.ts, claude.ts, ...  # Model classes
        └── custom-*.ts  # Custom provider model classes