mirror of
https://github.com/farion1231/cc-switch.git
synced 2026-07-24 12:44:18 +08:00
Dex Miller
3553d05bf0
* feat(provider): support additive provider key lifecycle management
Add `addToLive` parameter to add_provider so callers can opt out of
writing to the live config (e.g. when duplicating an inactive provider).
Add `originalId` parameter to update_provider to support provider key
renames — the old key is removed from live config before the new one
is written.
Frontend: ProviderForm now exposes provider-key input for openclaw app
type, and EditProviderDialog forwards originalId on save. Deep-link
import passes addToLive=true to preserve existing behavior.
* test(provider): add integration tests for additive provider key flows
Cover openclaw provider duplication scenario to verify that a generated
provider key is assigned automatically. Add MSW handlers for
get_openclaw_live_provider_ids, get_openclaw_default_model,
scan_openclaw_config_health, and check_env_conflicts endpoints.
Update EditProviderDialog mock to pass originalId alongside provider.
* fix(openclaw): replace json-five serializer to prevent panic on empty collections
json-five 0.3.1 panics when pretty-printing nested empty maps/arrays.
Switch value_to_rt_value() to serde_json::to_string_pretty() which
produces valid JSON5 output without the panic. Add regression test for
removing the last provider (empty providers map).
* style: apply rustfmt formatting to proxy and provider modules
Reformat chained .header() calls in ClaudeAdapter and StreamCheckService
for consistent alignment. Reorder imports alphabetically in stream_check.
Fix trailing whitespace in transform.rs and merge import lines in
provider/mod.rs.
* style: fix clippy warnings in live.rs and tray.rs
* refactor(provider): simplify live_config_managed and deduplicate tolerant live config checks
- Change live_config_managed from Option<bool> to bool with #[serde(default)]
- Extract repeated tolerant live config query into check_live_config_exists helper
- Fix duplicate key generation to also check live-only provider IDs
- Fix updateProvider test to match new { provider, originalId } call signature
- Add streaming_responses test type annotation for compiler inference
* fix(provider): distinguish legacy providers from db-only when tolerating live config errors
Change `ProviderMeta.live_config_managed` from `bool` to `Option<bool>`
to introduce a three-state semantic:
- `Some(true)`: provider has been written to live config
- `Some(false)`: explicitly db-only, never written to live config
- `None`: legacy data or unknown state (pre-existing providers)
Previously, legacy providers defaulted to `live_config_managed = false`
via `#[serde(default)]`, which silently swallowed live config parse
errors. This could mask genuine configuration issues for providers that
had actually been synced to live config before the field was introduced.
Now, only providers with an explicit `Some(false)` marker tolerate parse
errors; legacy `None` providers surface errors as before, preserving
safety for already-managed configurations.
Also wrap the `ensureQueryData` call for live provider IDs during
duplication in a try/catch so that a malformed config file shows a
user-facing toast instead of silently failing.
Add tests for both the legacy error propagation path and the frontend
duplication failure scenario.
* refactor(provider): unify OMO variant updates with atomic file-then-db writes and rollback
Consolidate the duplicated omo/omo-slim update branches into a single
match on the variant. Write the OMO config file from the in-memory
provider state *before* persisting to the database, so a file-write or
plugin-sync failure leaves the database unchanged. If `add_plugin`
fails after the config file is already written, roll back to the
previous on-disk contents via snapshot/restore.
Also:
- `sync_all_providers_to_live` now skips db-only providers
(`live_config_managed == Some(false)`) instead of attempting to write
them to live config.
- `import_{opencode,openclaw}_providers_from_live` mark imported
providers as `live_config_managed: Some(true)` so they are correctly
recognized during subsequent syncs.
- Extract OmoService helpers: `profile_data_from_provider`,
`snapshot_config_file`, `restore_config_file`, `write_profile_config`,
and the new public `write_provider_config_to_file`.
- Add 9 new tests covering sync skip, legacy restore, import marking,
OMO persistence, file-write failure, and plugin-sync rollback.
* fix(provider): fix additive provider delete/switch regressions and redundancy
- fix(delete): replace stale live_config_managed flag check with
check_live_config_exists so providers written to live before the
flag-flip logic was introduced are still cleaned up on delete
- fix(switch): make write_live_with_common_config return Err instead of
silently returning Ok when config structure is invalid, preventing
live_config_managed from being incorrectly flipped to true
- fix(update): block provider key rename for OMO/OMO Slim categories to
prevent orphaned current-state markers breaking OMO file syncs
- fix(switch): flip live_config_managed to true after successful live
write for DB-only additive providers so sync_all_providers_to_live
includes them on future syncs; roll back live write if DB update fails
- refactor(delete): merge symmetric OMO/OMO-Slim blocks into single
match-on-variant path; hoist DB read to top of additive branch
- refactor(remove_from_live_config): merge OMO/OMO-Slim if/else-if
into single match-on-variant path
- refactor(switch_normal): merge two OMO/OMO-Slim if blocks into one
OpenCode guard with (enable, disable) variant pair
- fix(update): remove redundant duplicate return Ok(true) after OMO
current-state write
* fix(test): use preferred_filename after OMO field rename
The merge from main brought in #1746 which renamed
OmoVariant.filename → preferred_filename, but the test helper
omo_config_path() was not updated, breaking compilation of all
new provider tests.
---------
Co-authored-by: Jason <farion1231@gmail.com>
1020 lines
35 KiB
Rust
1020 lines
35 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, PartialEq, Eq, Default)]
|
||
#[serde(rename_all = "snake_case")]
|
||
pub enum AuthBindingSource {
|
||
/// 从 provider 自身配置读取认证信息（默认）
|
||
#[default]
|
||
ProviderConfig,
|
||
/// 使用托管账号认证（如 GitHub Copilot OAuth）
|
||
ManagedAccount,
|
||
}
|
||
|
||
/// 通用认证绑定
|
||
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
|
||
pub struct AuthBinding {
|
||
/// 认证来源
|
||
#[serde(default)]
|
||
pub source: AuthBindingSource,
|
||
/// 托管认证供应商标识（如 github_copilot）
|
||
#[serde(rename = "authProvider", skip_serializing_if = "Option::is_none")]
|
||
pub auth_provider: Option<String>,
|
||
/// 托管账号 ID；为空表示跟随该认证供应商的默认账号
|
||
#[serde(rename = "accountId", skip_serializing_if = "Option::is_none")]
|
||
pub account_id: 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>,
|
||
/// 是否在写入 live 时应用通用配置片段
|
||
#[serde(
|
||
rename = "commonConfigEnabled",
|
||
skip_serializing_if = "Option::is_none"
|
||
)]
|
||
pub common_config_enabled: Option<bool>,
|
||
/// 用量查询脚本配置
|
||
#[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 格式，需要转换
|
||
/// - "openai_responses": OpenAI Responses API 格式，需要转换
|
||
#[serde(rename = "apiFormat", skip_serializing_if = "Option::is_none")]
|
||
pub api_format: Option<String>,
|
||
/// 通用认证绑定（provider_config / managed_account）
|
||
///
|
||
/// 新代码应只写入该字段；githubAccountId 仅保留兼容读取。
|
||
#[serde(rename = "authBinding", skip_serializing_if = "Option::is_none")]
|
||
pub auth_binding: Option<AuthBinding>,
|
||
/// Claude 认证字段名（"ANTHROPIC_AUTH_TOKEN" 或 "ANTHROPIC_API_KEY"）
|
||
#[serde(rename = "apiKeyField", skip_serializing_if = "Option::is_none")]
|
||
pub api_key_field: Option<String>,
|
||
/// 是否将 base_url 视为完整 API 端点（不拼接 endpoint 路径）
|
||
#[serde(rename = "isFullUrl", skip_serializing_if = "Option::is_none")]
|
||
pub is_full_url: Option<bool>,
|
||
/// Prompt cache key for OpenAI-compatible endpoints.
|
||
/// When set, injected into converted requests to improve cache hit rate.
|
||
/// If not set, provider ID is used automatically during format conversion.
|
||
#[serde(rename = "promptCacheKey", skip_serializing_if = "Option::is_none")]
|
||
pub prompt_cache_key: Option<String>,
|
||
/// 累加模式应用中，该 provider 是否已写入 live config。
|
||
/// `None` 表示旧数据/未知状态，`Some(false)` 表示明确仅存在于数据库中。
|
||
#[serde(rename = "liveConfigManaged", skip_serializing_if = "Option::is_none")]
|
||
pub live_config_managed: Option<bool>,
|
||
/// 供应商类型标识（用于特殊供应商检测）
|
||
/// - "github_copilot": GitHub Copilot 供应商
|
||
#[serde(rename = "providerType", skip_serializing_if = "Option::is_none")]
|
||
pub provider_type: Option<String>,
|
||
/// GitHub Copilot 关联账号 ID（仅 github_copilot 供应商使用）
|
||
/// 用于多账号支持，关联到特定的 GitHub 账号
|
||
#[serde(rename = "githubAccountId", skip_serializing_if = "Option::is_none")]
|
||
pub github_account_id: Option<String>,
|
||
}
|
||
|
||
impl ProviderMeta {
|
||
/// 解析指定托管认证供应商绑定的账号 ID。
|
||
///
|
||
/// 新版优先读取 authBinding，旧版继续兼容 githubAccountId。
|
||
pub fn managed_account_id_for(&self, auth_provider: &str) -> Option<String> {
|
||
if let Some(binding) = self.auth_binding.as_ref() {
|
||
if binding.source == AuthBindingSource::ManagedAccount
|
||
&& binding.auth_provider.as_deref() == Some(auth_provider)
|
||
{
|
||
return binding.account_id.clone();
|
||
}
|
||
}
|
||
|
||
if auth_provider == "github_copilot" {
|
||
return self.github_account_id.clone();
|
||
}
|
||
|
||
None
|
||
}
|
||
}
|
||
|
||
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"));
|
||
}
|
||
}
|