mirror of
https://github.com/farion1231/cc-switch.git
synced 2026-06-16 13:34:04 +08:00
Jason Young
992dda5c5c
* refactor(provider): switch from full config overwrite to partial key-field merging Replace the provider switching mechanism for Claude/Codex/Gemini from full settings_config overwrite to partial key-field replacement, preserving user's non-provider settings (plugins, MCP, permissions, etc.) across switches. - Add write_live_partial() with per-app implementations for Claude (JSON env merge), Codex (auth replace + TOML partial merge), and Gemini (env merge) - Add backfill_key_fields() to extract only provider-specific fields when saving live config back to provider entries - Update switch_normal, sync_current_to_live, add, update to use partial merge - Remove common config snippet feature for Claude/Codex/Gemini (no longer needed with partial merging); preserve OMO common config - Delete 6 frontend files (3 components + 3 hooks), clean up 11 modified files - Remove backend extract_common_config_* methods, 3 Tauri commands, CommonConfigSnippets struct, and related migration code - Update integration tests to validate key-field-only backfill behavior * refactor(cleanup): remove dead code and redundant MCP sync after partial-merge refactor - Remove ConfigService legacy full-overwrite sync methods (~150 lines) - Remove redundant McpService::sync_all_enabled from switch_normal - Switch proxy fallback recovery from write_live_snapshot to write_live_partial - Remove dead ProviderService::write_gemini_live wrapper - Update tests to reflect partial-merge behavior (MCP preserved, not re-synced) * feat(claude): add Quick Toggles for common Claude Code preferences Add checkbox toggles for hideAttribution, alwaysThinking, and enableTeammates that write directly to the live settings file via RFC 7396 JSON Merge Patch. Mirror changes to the form editor using form.watch for reactive updates. * fix(provider): add missing key fields to partial-merge constants Add provider-specific fields verified against official docs to prevent key residue or loss during provider switching: - Claude: CLAUDE_CODE_SUBAGENT_MODEL (env), model (top-level) - Codex: review_model, plan_mode_reasoning_effort - Gemini: GOOGLE_API_KEY (official alternative to GEMINI_API_KEY) * fix(provider): expand partial-merge key fields for Bedrock, Vertex, Foundry and behavior settings Add missing env/top-level fields to CLAUDE_KEY_ENV_FIELDS and CLAUDE_KEY_TOP_LEVEL so that provider switching correctly replaces (and clears) credentials and flags for AWS Bedrock, Google Vertex AI, Microsoft Foundry, and provider behavior overrides like max output tokens and prompt caching. * feat(provider): add auth field selector for Claude providers (AUTH_TOKEN / API_KEY) Allow users to choose between ANTHROPIC_AUTH_TOKEN and ANTHROPIC_API_KEY when creating or editing custom Claude providers, persisted in meta.apiKeyField. * refactor(preset): remove AiHubMix hardcoded API_KEY in favor of generic auth selector AiHubMix was the only preset that hardcoded ANTHROPIC_API_KEY before the generic auth field selector was introduced. Now that users can freely choose between AUTH_TOKEN and API_KEY via the UI, remove the special-case and default AiHubMix to the standard ANTHROPIC_AUTH_TOKEN.
944 lines
32 KiB
Rust
944 lines
32 KiB
Rust
use indexmap::IndexMap;
|
||
use serde::{Deserialize, Serialize};
|
||
use serde_json::Value;
|
||
use std::collections::HashMap;
|
||
|
||
// SSOT 模式：不再写供应商副本文件
|
||
|
||
/// 供应商结构体
|
||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||
pub struct Provider {
|
||
pub id: String,
|
||
pub name: String,
|
||
#[serde(rename = "settingsConfig")]
|
||
pub settings_config: Value,
|
||
#[serde(skip_serializing_if = "Option::is_none")]
|
||
#[serde(rename = "websiteUrl")]
|
||
pub website_url: Option<String>,
|
||
#[serde(skip_serializing_if = "Option::is_none")]
|
||
pub category: Option<String>,
|
||
#[serde(skip_serializing_if = "Option::is_none")]
|
||
#[serde(rename = "createdAt")]
|
||
pub created_at: Option<i64>,
|
||
#[serde(skip_serializing_if = "Option::is_none")]
|
||
#[serde(rename = "sortIndex")]
|
||
pub sort_index: Option<usize>,
|
||
/// 备注信息
|
||
#[serde(skip_serializing_if = "Option::is_none")]
|
||
pub notes: Option<String>,
|
||
/// 供应商元数据（不写入 live 配置，仅存于 ~/.cc-switch/config.json）
|
||
#[serde(skip_serializing_if = "Option::is_none")]
|
||
pub meta: Option<ProviderMeta>,
|
||
/// 图标名称（如 "openai", "anthropic"）
|
||
#[serde(skip_serializing_if = "Option::is_none")]
|
||
pub icon: Option<String>,
|
||
/// 图标颜色（Hex 格式，如 "#00A67E"）
|
||
#[serde(skip_serializing_if = "Option::is_none")]
|
||
#[serde(rename = "iconColor")]
|
||
pub icon_color: Option<String>,
|
||
/// 是否加入故障转移队列
|
||
#[serde(default)]
|
||
#[serde(rename = "inFailoverQueue")]
|
||
pub in_failover_queue: bool,
|
||
}
|
||
|
||
impl Provider {
|
||
/// 从现有ID创建供应商
|
||
pub fn with_id(
|
||
id: String,
|
||
name: String,
|
||
settings_config: Value,
|
||
website_url: Option<String>,
|
||
) -> Self {
|
||
Self {
|
||
id,
|
||
name,
|
||
settings_config,
|
||
website_url,
|
||
category: None,
|
||
created_at: None,
|
||
sort_index: None,
|
||
notes: None,
|
||
meta: None,
|
||
icon: None,
|
||
icon_color: None,
|
||
in_failover_queue: false,
|
||
}
|
||
}
|
||
}
|
||
|
||
/// 供应商管理器
|
||
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
|
||
pub struct ProviderManager {
|
||
pub providers: IndexMap<String, Provider>,
|
||
pub current: String,
|
||
}
|
||
|
||
/// 用量查询脚本配置
|
||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||
pub struct UsageScript {
|
||
pub enabled: bool,
|
||
pub language: String,
|
||
pub code: String,
|
||
#[serde(skip_serializing_if = "Option::is_none")]
|
||
pub timeout: Option<u64>,
|
||
/// 用量查询专用的 API Key（通用模板使用）
|
||
#[serde(skip_serializing_if = "Option::is_none")]
|
||
#[serde(rename = "apiKey")]
|
||
pub api_key: Option<String>,
|
||
/// 用量查询专用的 Base URL（通用和 NewAPI 模板使用）
|
||
#[serde(skip_serializing_if = "Option::is_none")]
|
||
#[serde(rename = "baseUrl")]
|
||
pub base_url: Option<String>,
|
||
/// 访问令牌（用于需要登录的接口，NewAPI 模板使用）
|
||
#[serde(skip_serializing_if = "Option::is_none")]
|
||
#[serde(rename = "accessToken")]
|
||
pub access_token: Option<String>,
|
||
/// 用户ID（用于需要用户标识的接口，NewAPI 模板使用）
|
||
#[serde(skip_serializing_if = "Option::is_none")]
|
||
#[serde(rename = "userId")]
|
||
pub user_id: Option<String>,
|
||
/// 模板类型（用于后端判断验证规则）
|
||
#[serde(skip_serializing_if = "Option::is_none")]
|
||
#[serde(rename = "templateType")]
|
||
pub template_type: Option<String>,
|
||
/// 自动查询间隔（单位：分钟，0 表示禁用自动查询）
|
||
#[serde(skip_serializing_if = "Option::is_none")]
|
||
#[serde(rename = "autoQueryInterval")]
|
||
pub auto_query_interval: Option<u64>,
|
||
}
|
||
|
||
/// 用量数据
|
||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||
pub struct UsageData {
|
||
#[serde(skip_serializing_if = "Option::is_none")]
|
||
#[serde(rename = "planName")]
|
||
pub plan_name: Option<String>,
|
||
#[serde(skip_serializing_if = "Option::is_none")]
|
||
pub extra: Option<String>,
|
||
#[serde(skip_serializing_if = "Option::is_none")]
|
||
#[serde(rename = "isValid")]
|
||
pub is_valid: Option<bool>,
|
||
#[serde(skip_serializing_if = "Option::is_none")]
|
||
#[serde(rename = "invalidMessage")]
|
||
pub invalid_message: Option<String>,
|
||
#[serde(skip_serializing_if = "Option::is_none")]
|
||
pub total: Option<f64>,
|
||
#[serde(skip_serializing_if = "Option::is_none")]
|
||
pub used: Option<f64>,
|
||
#[serde(skip_serializing_if = "Option::is_none")]
|
||
pub remaining: Option<f64>,
|
||
#[serde(skip_serializing_if = "Option::is_none")]
|
||
pub unit: Option<String>,
|
||
}
|
||
|
||
/// 用量查询结果（支持多套餐）
|
||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||
pub struct UsageResult {
|
||
pub success: bool,
|
||
#[serde(skip_serializing_if = "Option::is_none")]
|
||
pub data: Option<Vec<UsageData>>, // 支持返回多个套餐
|
||
#[serde(skip_serializing_if = "Option::is_none")]
|
||
pub error: Option<String>,
|
||
}
|
||
|
||
/// 供应商单独的模型测试配置
|
||
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
|
||
pub struct ProviderTestConfig {
|
||
/// 是否启用单独配置（false 时使用全局配置）
|
||
#[serde(default)]
|
||
pub enabled: bool,
|
||
/// 测试用的模型名称（覆盖全局配置）
|
||
#[serde(rename = "testModel", skip_serializing_if = "Option::is_none")]
|
||
pub test_model: Option<String>,
|
||
/// 超时时间（秒）
|
||
#[serde(rename = "timeoutSecs", skip_serializing_if = "Option::is_none")]
|
||
pub timeout_secs: Option<u64>,
|
||
/// 测试提示词
|
||
#[serde(rename = "testPrompt", skip_serializing_if = "Option::is_none")]
|
||
pub test_prompt: Option<String>,
|
||
/// 降级阈值（毫秒）
|
||
#[serde(
|
||
rename = "degradedThresholdMs",
|
||
skip_serializing_if = "Option::is_none"
|
||
)]
|
||
pub degraded_threshold_ms: Option<u64>,
|
||
/// 最大重试次数
|
||
#[serde(rename = "maxRetries", skip_serializing_if = "Option::is_none")]
|
||
pub max_retries: Option<u32>,
|
||
}
|
||
|
||
/// 供应商单独的代理配置
|
||
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
|
||
pub struct ProviderProxyConfig {
|
||
/// 是否启用单独配置（false 时使用全局/系统代理）
|
||
#[serde(default)]
|
||
pub enabled: bool,
|
||
/// 代理类型：http, https, socks5
|
||
#[serde(rename = "proxyType", skip_serializing_if = "Option::is_none")]
|
||
pub proxy_type: Option<String>,
|
||
/// 代理主机
|
||
#[serde(rename = "proxyHost", skip_serializing_if = "Option::is_none")]
|
||
pub proxy_host: Option<String>,
|
||
/// 代理端口
|
||
#[serde(rename = "proxyPort", skip_serializing_if = "Option::is_none")]
|
||
pub proxy_port: Option<u16>,
|
||
/// 代理用户名（可选）
|
||
#[serde(rename = "proxyUsername", skip_serializing_if = "Option::is_none")]
|
||
pub proxy_username: Option<String>,
|
||
/// 代理密码（可选）
|
||
#[serde(rename = "proxyPassword", skip_serializing_if = "Option::is_none")]
|
||
pub proxy_password: Option<String>,
|
||
}
|
||
|
||
/// 供应商元数据
|
||
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
|
||
pub struct ProviderMeta {
|
||
/// 自定义端点列表（按 URL 去重存储）
|
||
#[serde(default, skip_serializing_if = "HashMap::is_empty")]
|
||
pub custom_endpoints: HashMap<String, crate::settings::CustomEndpoint>,
|
||
/// 用量查询脚本配置
|
||
#[serde(skip_serializing_if = "Option::is_none")]
|
||
pub usage_script: Option<UsageScript>,
|
||
/// 请求地址管理：测速后自动选择最佳端点
|
||
#[serde(rename = "endpointAutoSelect", skip_serializing_if = "Option::is_none")]
|
||
pub endpoint_auto_select: Option<bool>,
|
||
/// 合作伙伴标记（前端使用 isPartner，保持字段名一致）
|
||
#[serde(rename = "isPartner", skip_serializing_if = "Option::is_none")]
|
||
pub is_partner: Option<bool>,
|
||
/// 合作伙伴促销 key，用于识别 PackyCode 等特殊供应商
|
||
#[serde(
|
||
rename = "partnerPromotionKey",
|
||
skip_serializing_if = "Option::is_none"
|
||
)]
|
||
pub partner_promotion_key: Option<String>,
|
||
/// 成本倍数（用于计算实际成本）
|
||
#[serde(rename = "costMultiplier", skip_serializing_if = "Option::is_none")]
|
||
pub cost_multiplier: Option<String>,
|
||
/// 计费模式来源（response/request）
|
||
#[serde(rename = "pricingModelSource", skip_serializing_if = "Option::is_none")]
|
||
pub pricing_model_source: Option<String>,
|
||
/// 每日消费限额（USD）
|
||
#[serde(rename = "limitDailyUsd", skip_serializing_if = "Option::is_none")]
|
||
pub limit_daily_usd: Option<String>,
|
||
/// 每月消费限额（USD）
|
||
#[serde(rename = "limitMonthlyUsd", skip_serializing_if = "Option::is_none")]
|
||
pub limit_monthly_usd: Option<String>,
|
||
/// 供应商单独的模型测试配置
|
||
#[serde(rename = "testConfig", skip_serializing_if = "Option::is_none")]
|
||
pub test_config: Option<ProviderTestConfig>,
|
||
/// 供应商单独的代理配置
|
||
#[serde(rename = "proxyConfig", skip_serializing_if = "Option::is_none")]
|
||
pub proxy_config: Option<ProviderProxyConfig>,
|
||
/// Claude API 格式（仅 Claude 供应商使用）
|
||
/// - "anthropic": 原生 Anthropic Messages API，直接透传
|
||
/// - "openai_chat": OpenAI Chat Completions 格式，需要转换
|
||
#[serde(rename = "apiFormat", skip_serializing_if = "Option::is_none")]
|
||
pub api_format: Option<String>,
|
||
/// Claude 认证字段名（仅 Claude 供应商使用）
|
||
/// - "ANTHROPIC_AUTH_TOKEN" (默认): 大多数第三方/聚合供应商
|
||
/// - "ANTHROPIC_API_KEY": 少数供应商需要原生 API Key
|
||
#[serde(rename = "apiKeyField", skip_serializing_if = "Option::is_none")]
|
||
pub api_key_field: Option<String>,
|
||
}
|
||
|
||
impl ProviderManager {
|
||
/// 获取所有供应商
|
||
pub fn get_all_providers(&self) -> &IndexMap<String, Provider> {
|
||
&self.providers
|
||
}
|
||
}
|
||
|
||
// ============================================================================
|
||
// 统一供应商（Universal Provider）- 跨应用共享配置
|
||
// ============================================================================
|
||
|
||
/// 统一供应商的应用启用状态
|
||
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
|
||
pub struct UniversalProviderApps {
|
||
#[serde(default)]
|
||
pub claude: bool,
|
||
#[serde(default)]
|
||
pub codex: bool,
|
||
#[serde(default)]
|
||
pub gemini: bool,
|
||
}
|
||
|
||
/// Claude 模型配置
|
||
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
|
||
pub struct ClaudeModelConfig {
|
||
/// 主模型
|
||
#[serde(skip_serializing_if = "Option::is_none")]
|
||
pub model: Option<String>,
|
||
/// Haiku 默认模型
|
||
#[serde(skip_serializing_if = "Option::is_none")]
|
||
#[serde(rename = "haikuModel")]
|
||
pub haiku_model: Option<String>,
|
||
/// Sonnet 默认模型
|
||
#[serde(skip_serializing_if = "Option::is_none")]
|
||
#[serde(rename = "sonnetModel")]
|
||
pub sonnet_model: Option<String>,
|
||
/// Opus 默认模型
|
||
#[serde(skip_serializing_if = "Option::is_none")]
|
||
#[serde(rename = "opusModel")]
|
||
pub opus_model: Option<String>,
|
||
}
|
||
|
||
/// Codex 模型配置
|
||
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
|
||
pub struct CodexModelConfig {
|
||
/// 模型名称
|
||
#[serde(skip_serializing_if = "Option::is_none")]
|
||
pub model: Option<String>,
|
||
/// 推理强度
|
||
#[serde(skip_serializing_if = "Option::is_none")]
|
||
#[serde(rename = "reasoningEffort")]
|
||
pub reasoning_effort: Option<String>,
|
||
}
|
||
|
||
/// Gemini 模型配置
|
||
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
|
||
pub struct GeminiModelConfig {
|
||
/// 模型名称
|
||
#[serde(skip_serializing_if = "Option::is_none")]
|
||
pub model: Option<String>,
|
||
}
|
||
|
||
/// 各应用的模型配置
|
||
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
|
||
pub struct UniversalProviderModels {
|
||
#[serde(skip_serializing_if = "Option::is_none")]
|
||
pub claude: Option<ClaudeModelConfig>,
|
||
#[serde(skip_serializing_if = "Option::is_none")]
|
||
pub codex: Option<CodexModelConfig>,
|
||
#[serde(skip_serializing_if = "Option::is_none")]
|
||
pub gemini: Option<GeminiModelConfig>,
|
||
}
|
||
|
||
/// 统一供应商（跨应用共享配置）
|
||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||
pub struct UniversalProvider {
|
||
/// 唯一标识
|
||
pub id: String,
|
||
/// 供应商名称
|
||
pub name: String,
|
||
/// 供应商类型（如 "newapi", "custom"）
|
||
#[serde(rename = "providerType")]
|
||
pub provider_type: String,
|
||
/// 应用启用状态
|
||
pub apps: UniversalProviderApps,
|
||
/// API 基础地址
|
||
#[serde(rename = "baseUrl")]
|
||
pub base_url: String,
|
||
/// API 密钥
|
||
#[serde(rename = "apiKey")]
|
||
pub api_key: String,
|
||
/// 各应用的模型配置
|
||
#[serde(default)]
|
||
pub models: UniversalProviderModels,
|
||
/// 网站链接
|
||
#[serde(skip_serializing_if = "Option::is_none")]
|
||
#[serde(rename = "websiteUrl")]
|
||
pub website_url: Option<String>,
|
||
/// 备注信息
|
||
#[serde(skip_serializing_if = "Option::is_none")]
|
||
pub notes: Option<String>,
|
||
/// 图标名称
|
||
#[serde(skip_serializing_if = "Option::is_none")]
|
||
pub icon: Option<String>,
|
||
/// 图标颜色
|
||
#[serde(skip_serializing_if = "Option::is_none")]
|
||
#[serde(rename = "iconColor")]
|
||
pub icon_color: Option<String>,
|
||
/// 元数据
|
||
#[serde(skip_serializing_if = "Option::is_none")]
|
||
pub meta: Option<ProviderMeta>,
|
||
/// 创建时间戳
|
||
#[serde(skip_serializing_if = "Option::is_none")]
|
||
#[serde(rename = "createdAt")]
|
||
pub created_at: Option<i64>,
|
||
/// 排序索引
|
||
#[serde(skip_serializing_if = "Option::is_none")]
|
||
#[serde(rename = "sortIndex")]
|
||
pub sort_index: Option<usize>,
|
||
}
|
||
|
||
impl UniversalProvider {
|
||
/// 创建新的统一供应商
|
||
pub fn new(
|
||
id: String,
|
||
name: String,
|
||
provider_type: String,
|
||
base_url: String,
|
||
api_key: String,
|
||
) -> Self {
|
||
Self {
|
||
id,
|
||
name,
|
||
provider_type,
|
||
apps: UniversalProviderApps::default(),
|
||
base_url,
|
||
api_key,
|
||
models: UniversalProviderModels::default(),
|
||
website_url: None,
|
||
notes: None,
|
||
icon: None,
|
||
icon_color: None,
|
||
meta: None,
|
||
created_at: Some(chrono::Utc::now().timestamp_millis()),
|
||
sort_index: None,
|
||
}
|
||
}
|
||
|
||
/// 生成 Claude 供应商配置
|
||
pub fn to_claude_provider(&self) -> Option<Provider> {
|
||
if !self.apps.claude {
|
||
return None;
|
||
}
|
||
|
||
let models = self.models.claude.as_ref();
|
||
let model = models
|
||
.and_then(|m| m.model.clone())
|
||
.unwrap_or_else(|| "claude-sonnet-4-20250514".to_string());
|
||
let haiku = models
|
||
.and_then(|m| m.haiku_model.clone())
|
||
.unwrap_or_else(|| model.clone());
|
||
let sonnet = models
|
||
.and_then(|m| m.sonnet_model.clone())
|
||
.unwrap_or_else(|| model.clone());
|
||
let opus = models
|
||
.and_then(|m| m.opus_model.clone())
|
||
.unwrap_or_else(|| model.clone());
|
||
|
||
let settings_config = serde_json::json!({
|
||
"env": {
|
||
"ANTHROPIC_BASE_URL": self.base_url,
|
||
"ANTHROPIC_AUTH_TOKEN": self.api_key,
|
||
"ANTHROPIC_MODEL": model,
|
||
"ANTHROPIC_DEFAULT_HAIKU_MODEL": haiku,
|
||
"ANTHROPIC_DEFAULT_SONNET_MODEL": sonnet,
|
||
"ANTHROPIC_DEFAULT_OPUS_MODEL": opus,
|
||
}
|
||
});
|
||
|
||
Some(Provider {
|
||
id: format!("universal-claude-{}", self.id),
|
||
name: self.name.clone(),
|
||
settings_config,
|
||
website_url: self.website_url.clone(),
|
||
category: Some("aggregator".to_string()),
|
||
created_at: self.created_at,
|
||
sort_index: self.sort_index,
|
||
notes: self.notes.clone(),
|
||
meta: self.meta.clone(),
|
||
icon: self.icon.clone(),
|
||
icon_color: self.icon_color.clone(),
|
||
in_failover_queue: false,
|
||
})
|
||
}
|
||
|
||
/// 生成 Codex 供应商配置
|
||
pub fn to_codex_provider(&self) -> Option<Provider> {
|
||
if !self.apps.codex {
|
||
return None;
|
||
}
|
||
|
||
let models = self.models.codex.as_ref();
|
||
let model = models
|
||
.and_then(|m| m.model.clone())
|
||
.unwrap_or_else(|| "gpt-4o".to_string());
|
||
let reasoning_effort = models
|
||
.and_then(|m| m.reasoning_effort.clone())
|
||
.unwrap_or_else(|| "high".to_string());
|
||
|
||
// Codex/OpenAI 的 base_url 既可能是纯 origin（需要补 /v1），也可能包含自定义前缀（不应强行补版本）
|
||
let base_trimmed = self.base_url.trim_end_matches('/');
|
||
let origin_only = match base_trimmed.split_once("://") {
|
||
Some((_scheme, rest)) => !rest.contains('/'),
|
||
None => !base_trimmed.contains('/'),
|
||
};
|
||
let codex_base_url = if base_trimmed.ends_with("/v1") {
|
||
base_trimmed.to_string()
|
||
} else if origin_only {
|
||
format!("{base_trimmed}/v1")
|
||
} else {
|
||
base_trimmed.to_string()
|
||
};
|
||
|
||
// 生成 Codex 的 config.toml 内容
|
||
let config_toml = format!(
|
||
r#"model_provider = "newapi"
|
||
model = "{model}"
|
||
model_reasoning_effort = "{reasoning_effort}"
|
||
disable_response_storage = true
|
||
|
||
[model_providers.newapi]
|
||
name = "NewAPI"
|
||
base_url = "{codex_base_url}"
|
||
wire_api = "responses"
|
||
requires_openai_auth = true"#
|
||
);
|
||
|
||
let settings_config = serde_json::json!({
|
||
"auth": {
|
||
"OPENAI_API_KEY": self.api_key
|
||
},
|
||
"config": config_toml
|
||
});
|
||
|
||
Some(Provider {
|
||
id: format!("universal-codex-{}", self.id),
|
||
name: self.name.clone(),
|
||
settings_config,
|
||
website_url: self.website_url.clone(),
|
||
category: Some("aggregator".to_string()),
|
||
created_at: self.created_at,
|
||
sort_index: self.sort_index,
|
||
notes: self.notes.clone(),
|
||
meta: self.meta.clone(),
|
||
icon: self.icon.clone(),
|
||
icon_color: self.icon_color.clone(),
|
||
in_failover_queue: false,
|
||
})
|
||
}
|
||
|
||
/// 生成 Gemini 供应商配置
|
||
pub fn to_gemini_provider(&self) -> Option<Provider> {
|
||
if !self.apps.gemini {
|
||
return None;
|
||
}
|
||
|
||
let models = self.models.gemini.as_ref();
|
||
let model = models
|
||
.and_then(|m| m.model.clone())
|
||
.unwrap_or_else(|| "gemini-2.5-pro".to_string());
|
||
|
||
let settings_config = serde_json::json!({
|
||
"env": {
|
||
"GOOGLE_GEMINI_BASE_URL": self.base_url,
|
||
"GEMINI_API_KEY": self.api_key,
|
||
"GEMINI_MODEL": model,
|
||
}
|
||
});
|
||
|
||
Some(Provider {
|
||
id: format!("universal-gemini-{}", self.id),
|
||
name: self.name.clone(),
|
||
settings_config,
|
||
website_url: self.website_url.clone(),
|
||
category: Some("aggregator".to_string()),
|
||
created_at: self.created_at,
|
||
sort_index: self.sort_index,
|
||
notes: self.notes.clone(),
|
||
meta: self.meta.clone(),
|
||
icon: self.icon.clone(),
|
||
icon_color: self.icon_color.clone(),
|
||
in_failover_queue: false,
|
||
})
|
||
}
|
||
}
|
||
|
||
// ============================================================================
|
||
// OpenCode 供应商配置结构
|
||
// ============================================================================
|
||
|
||
/// OpenCode 供应商的 settings_config 结构
|
||
///
|
||
/// OpenCode 使用 AI SDK 包名来指定供应商类型，与其他应用的配置格式不同。
|
||
/// 配置示例：
|
||
/// ```json
|
||
/// {
|
||
/// "npm": "@ai-sdk/openai-compatible",
|
||
/// "options": { "baseURL": "https://api.example.com/v1", "apiKey": "sk-xxx" },
|
||
/// "models": { "gpt-4o": { "name": "GPT-4o" } }
|
||
/// }
|
||
/// ```
|
||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||
pub struct OpenCodeProviderConfig {
|
||
/// AI SDK 包名，如 "@ai-sdk/openai-compatible", "@ai-sdk/anthropic"
|
||
pub npm: String,
|
||
|
||
/// 供应商名称（可选，用于显示）
|
||
#[serde(skip_serializing_if = "Option::is_none")]
|
||
pub name: Option<String>,
|
||
|
||
/// 供应商选项（API 密钥、基础 URL 等）
|
||
#[serde(default)]
|
||
pub options: OpenCodeProviderOptions,
|
||
|
||
/// 模型定义映射
|
||
#[serde(default)]
|
||
pub models: HashMap<String, OpenCodeModel>,
|
||
}
|
||
|
||
impl Default for OpenCodeProviderConfig {
|
||
fn default() -> Self {
|
||
Self {
|
||
npm: "@ai-sdk/openai-compatible".to_string(),
|
||
name: None,
|
||
options: OpenCodeProviderOptions::default(),
|
||
models: HashMap::new(),
|
||
}
|
||
}
|
||
}
|
||
|
||
/// OpenCode 供应商选项
|
||
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
|
||
pub struct OpenCodeProviderOptions {
|
||
/// API 基础 URL
|
||
#[serde(rename = "baseURL", skip_serializing_if = "Option::is_none")]
|
||
pub base_url: Option<String>,
|
||
|
||
/// API 密钥（支持环境变量引用，如 "{env:API_KEY}"）
|
||
#[serde(rename = "apiKey", skip_serializing_if = "Option::is_none")]
|
||
pub api_key: Option<String>,
|
||
|
||
/// 自定义请求头
|
||
#[serde(skip_serializing_if = "Option::is_none")]
|
||
pub headers: Option<HashMap<String, String>>,
|
||
|
||
/// 额外选项（timeout, setCacheKey 等）
|
||
/// 使用 flatten 捕获所有未明确定义的字段
|
||
#[serde(flatten, default, skip_serializing_if = "HashMap::is_empty")]
|
||
pub extra: HashMap<String, Value>,
|
||
}
|
||
|
||
/// OpenCode 模型定义
|
||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||
pub struct OpenCodeModel {
|
||
/// 模型显示名称
|
||
pub name: String,
|
||
|
||
/// 模型限制（上下文和输出 token 数）
|
||
#[serde(skip_serializing_if = "Option::is_none")]
|
||
pub limit: Option<OpenCodeModelLimit>,
|
||
|
||
/// 模型额外选项（provider 路由等）
|
||
#[serde(skip_serializing_if = "Option::is_none")]
|
||
pub options: Option<HashMap<String, Value>>,
|
||
|
||
/// 额外字段（cost、modalities、thinking、variants 等）
|
||
/// 使用 flatten 捕获所有未明确定义的字段
|
||
#[serde(flatten, default, skip_serializing_if = "HashMap::is_empty")]
|
||
pub extra: HashMap<String, Value>,
|
||
}
|
||
|
||
/// OpenCode 模型限制
|
||
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
|
||
pub struct OpenCodeModelLimit {
|
||
/// 上下文 token 限制
|
||
#[serde(skip_serializing_if = "Option::is_none")]
|
||
pub context: Option<u64>,
|
||
|
||
/// 输出 token 限制
|
||
#[serde(skip_serializing_if = "Option::is_none")]
|
||
pub output: Option<u64>,
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod tests {
|
||
use super::{
|
||
ClaudeModelConfig, CodexModelConfig, GeminiModelConfig, OpenCodeProviderConfig, Provider,
|
||
ProviderManager, ProviderMeta, UniversalProvider,
|
||
};
|
||
use serde_json::json;
|
||
|
||
#[test]
|
||
fn provider_meta_serializes_pricing_model_source() {
|
||
let mut meta = ProviderMeta::default();
|
||
meta.pricing_model_source = Some("response".to_string());
|
||
|
||
let value = serde_json::to_value(&meta).expect("serialize ProviderMeta");
|
||
|
||
assert_eq!(
|
||
value
|
||
.get("pricingModelSource")
|
||
.and_then(|item| item.as_str()),
|
||
Some("response")
|
||
);
|
||
assert!(value.get("pricing_model_source").is_none());
|
||
}
|
||
|
||
#[test]
|
||
fn provider_meta_omits_pricing_model_source_when_none() {
|
||
let meta = ProviderMeta::default();
|
||
let value = serde_json::to_value(&meta).expect("serialize ProviderMeta");
|
||
|
||
assert!(value.get("pricingModelSource").is_none());
|
||
}
|
||
|
||
#[test]
|
||
fn provider_with_id_populates_defaults() {
|
||
let settings_config = json!({
|
||
"env": { "API_KEY": "test" }
|
||
});
|
||
let provider = Provider::with_id(
|
||
"provider-1".to_string(),
|
||
"Provider".to_string(),
|
||
settings_config.clone(),
|
||
Some("https://example.com".to_string()),
|
||
);
|
||
|
||
assert_eq!(provider.id, "provider-1");
|
||
assert_eq!(provider.name, "Provider");
|
||
assert_eq!(provider.settings_config, settings_config);
|
||
assert_eq!(provider.website_url.as_deref(), Some("https://example.com"));
|
||
assert!(provider.category.is_none());
|
||
assert!(provider.created_at.is_none());
|
||
assert!(provider.sort_index.is_none());
|
||
assert!(provider.notes.is_none());
|
||
assert!(provider.meta.is_none());
|
||
assert!(provider.icon.is_none());
|
||
assert!(provider.icon_color.is_none());
|
||
assert!(!provider.in_failover_queue);
|
||
}
|
||
|
||
#[test]
|
||
fn provider_manager_get_all_providers_returns_map() {
|
||
let mut manager = ProviderManager::default();
|
||
let provider = Provider::with_id(
|
||
"provider-1".to_string(),
|
||
"Provider".to_string(),
|
||
json!({ "env": {} }),
|
||
None,
|
||
);
|
||
manager.providers.insert("provider-1".to_string(), provider);
|
||
|
||
assert_eq!(manager.get_all_providers().len(), 1);
|
||
assert!(manager.get_all_providers().contains_key("provider-1"));
|
||
}
|
||
|
||
#[test]
|
||
fn universal_provider_to_claude_provider_uses_models() {
|
||
let mut universal = UniversalProvider::new(
|
||
"u1".to_string(),
|
||
"Universal".to_string(),
|
||
"newapi".to_string(),
|
||
"https://api.example.com".to_string(),
|
||
"api-key".to_string(),
|
||
);
|
||
universal.apps.claude = true;
|
||
universal.models.claude = Some(ClaudeModelConfig {
|
||
model: Some("claude-main".to_string()),
|
||
haiku_model: Some("claude-haiku".to_string()),
|
||
sonnet_model: Some("claude-sonnet".to_string()),
|
||
opus_model: Some("claude-opus".to_string()),
|
||
});
|
||
|
||
let provider = universal.to_claude_provider().expect("claude provider");
|
||
|
||
assert_eq!(provider.id, "universal-claude-u1");
|
||
assert_eq!(provider.name, "Universal");
|
||
assert_eq!(provider.category.as_deref(), Some("aggregator"));
|
||
assert_eq!(
|
||
provider
|
||
.settings_config
|
||
.pointer("/env/ANTHROPIC_MODEL")
|
||
.and_then(|item| item.as_str()),
|
||
Some("claude-main")
|
||
);
|
||
assert_eq!(
|
||
provider
|
||
.settings_config
|
||
.pointer("/env/ANTHROPIC_DEFAULT_HAIKU_MODEL")
|
||
.and_then(|item| item.as_str()),
|
||
Some("claude-haiku")
|
||
);
|
||
assert_eq!(
|
||
provider
|
||
.settings_config
|
||
.pointer("/env/ANTHROPIC_DEFAULT_SONNET_MODEL")
|
||
.and_then(|item| item.as_str()),
|
||
Some("claude-sonnet")
|
||
);
|
||
assert_eq!(
|
||
provider
|
||
.settings_config
|
||
.pointer("/env/ANTHROPIC_DEFAULT_OPUS_MODEL")
|
||
.and_then(|item| item.as_str()),
|
||
Some("claude-opus")
|
||
);
|
||
}
|
||
|
||
#[test]
|
||
fn universal_provider_to_claude_provider_disabled_returns_none() {
|
||
let universal = UniversalProvider::new(
|
||
"u1".to_string(),
|
||
"Universal".to_string(),
|
||
"newapi".to_string(),
|
||
"https://api.example.com".to_string(),
|
||
"api-key".to_string(),
|
||
);
|
||
|
||
assert!(universal.to_claude_provider().is_none());
|
||
}
|
||
|
||
#[test]
|
||
fn universal_provider_to_codex_provider_appends_v1() {
|
||
let mut universal = UniversalProvider::new(
|
||
"u1".to_string(),
|
||
"Universal".to_string(),
|
||
"newapi".to_string(),
|
||
"https://api.example.com".to_string(),
|
||
"api-key".to_string(),
|
||
);
|
||
universal.apps.codex = true;
|
||
universal.models.codex = Some(CodexModelConfig {
|
||
model: Some("gpt-4o-mini".to_string()),
|
||
reasoning_effort: Some("low".to_string()),
|
||
});
|
||
|
||
let provider = universal.to_codex_provider().expect("codex provider");
|
||
let config = provider
|
||
.settings_config
|
||
.get("config")
|
||
.and_then(|item| item.as_str())
|
||
.expect("config toml");
|
||
|
||
assert!(config.contains("base_url = \"https://api.example.com/v1\""));
|
||
assert_eq!(
|
||
provider
|
||
.settings_config
|
||
.pointer("/auth/OPENAI_API_KEY")
|
||
.and_then(|item| item.as_str()),
|
||
Some("api-key")
|
||
);
|
||
}
|
||
|
||
#[test]
|
||
fn universal_provider_to_codex_provider_keeps_v1_suffix() {
|
||
let mut universal = UniversalProvider::new(
|
||
"u1".to_string(),
|
||
"Universal".to_string(),
|
||
"newapi".to_string(),
|
||
"https://api.example.com/v1".to_string(),
|
||
"api-key".to_string(),
|
||
);
|
||
universal.apps.codex = true;
|
||
|
||
let provider = universal.to_codex_provider().expect("codex provider");
|
||
let config = provider
|
||
.settings_config
|
||
.get("config")
|
||
.and_then(|item| item.as_str())
|
||
.expect("config toml");
|
||
|
||
assert!(config.contains("base_url = \"https://api.example.com/v1\""));
|
||
}
|
||
|
||
#[test]
|
||
fn universal_provider_to_codex_provider_disabled_returns_none() {
|
||
let universal = UniversalProvider::new(
|
||
"u1".to_string(),
|
||
"Universal".to_string(),
|
||
"newapi".to_string(),
|
||
"https://api.example.com".to_string(),
|
||
"api-key".to_string(),
|
||
);
|
||
|
||
assert!(universal.to_codex_provider().is_none());
|
||
}
|
||
|
||
#[test]
|
||
fn universal_provider_to_gemini_provider_defaults_model() {
|
||
let mut universal = UniversalProvider::new(
|
||
"u1".to_string(),
|
||
"Universal".to_string(),
|
||
"newapi".to_string(),
|
||
"https://api.example.com".to_string(),
|
||
"api-key".to_string(),
|
||
);
|
||
universal.apps.gemini = true;
|
||
|
||
let provider = universal.to_gemini_provider().expect("gemini provider");
|
||
|
||
assert_eq!(
|
||
provider
|
||
.settings_config
|
||
.pointer("/env/GEMINI_MODEL")
|
||
.and_then(|item| item.as_str()),
|
||
Some("gemini-2.5-pro")
|
||
);
|
||
}
|
||
|
||
#[test]
|
||
fn universal_provider_to_gemini_provider_uses_model() {
|
||
let mut universal = UniversalProvider::new(
|
||
"u1".to_string(),
|
||
"Universal".to_string(),
|
||
"newapi".to_string(),
|
||
"https://api.example.com".to_string(),
|
||
"api-key".to_string(),
|
||
);
|
||
universal.apps.gemini = true;
|
||
universal.models.gemini = Some(GeminiModelConfig {
|
||
model: Some("gemini-custom".to_string()),
|
||
});
|
||
|
||
let provider = universal.to_gemini_provider().expect("gemini provider");
|
||
|
||
assert_eq!(
|
||
provider
|
||
.settings_config
|
||
.pointer("/env/GEMINI_MODEL")
|
||
.and_then(|item| item.as_str()),
|
||
Some("gemini-custom")
|
||
);
|
||
}
|
||
|
||
#[test]
|
||
fn opencode_provider_config_defaults() {
|
||
let config = OpenCodeProviderConfig::default();
|
||
assert_eq!(config.npm, "@ai-sdk/openai-compatible");
|
||
assert!(config.name.is_none());
|
||
assert!(config.models.is_empty());
|
||
assert!(config.options.base_url.is_none());
|
||
assert!(config.options.api_key.is_none());
|
||
assert!(config.options.headers.is_none());
|
||
assert!(config.options.extra.is_empty());
|
||
}
|
||
|
||
#[test]
|
||
fn universal_codex_provider_origin_base_url_adds_v1() {
|
||
let mut p = UniversalProvider::new(
|
||
"id".to_string(),
|
||
"Test".to_string(),
|
||
"custom".to_string(),
|
||
"https://api.openai.com".to_string(),
|
||
"sk-test".to_string(),
|
||
);
|
||
p.apps.codex = true;
|
||
|
||
let provider = p.to_codex_provider().expect("should build codex provider");
|
||
let toml = provider
|
||
.settings_config
|
||
.get("config")
|
||
.and_then(|v| v.as_str())
|
||
.expect("config should be a toml string");
|
||
|
||
assert!(toml.contains("base_url = \"https://api.openai.com/v1\""));
|
||
}
|
||
|
||
#[test]
|
||
fn universal_codex_provider_custom_prefix_does_not_force_v1() {
|
||
let mut p = UniversalProvider::new(
|
||
"id".to_string(),
|
||
"Test".to_string(),
|
||
"custom".to_string(),
|
||
"https://example.com/openai".to_string(),
|
||
"sk-test".to_string(),
|
||
);
|
||
p.apps.codex = true;
|
||
|
||
let provider = p.to_codex_provider().expect("should build codex provider");
|
||
let toml = provider
|
||
.settings_config
|
||
.get("config")
|
||
.and_then(|v| v.as_str())
|
||
.expect("config should be a toml string");
|
||
|
||
assert!(toml.contains("base_url = \"https://example.com/openai\""));
|
||
assert!(!toml.contains("https://example.com/openai/v1"));
|
||
}
|
||
}
|