tenant.openagents/omega

1use std::sync::Arc;
2
3use collections::HashMap;
4use settings::RegisterSetting;
5
6use crate::provider::{
7    anthropic, anthropic::AnthropicSettings, anthropic_compatible::AnthropicCompatibleSettings,
8    bedrock, bedrock::AmazonBedrockSettings, cloud::ZedDotDevSettings, deepseek::DeepSeekSettings,
9    google::GoogleSettings, llama_cpp::LlamaCppSettings, lmstudio::LmStudioSettings, mistral,
10    mistral::MistralSettings, ollama::OllamaSettings, open_ai::OpenAiSettings,
11    open_ai_compatible::OpenAiCompatibleSettings, open_router, open_router::OpenRouterSettings,
12    opencode, opencode::OpenCodeSettings, resolve_custom_headers,
13    vercel_ai_gateway::VercelAiGatewaySettings, x_ai::XAiSettings,
14};
15
16#[derive(Debug, RegisterSetting)]
17pub struct AllLanguageModelSettings {
18    pub anthropic: AnthropicSettings,
19    pub anthropic_compatible: HashMap<Arc<str>, AnthropicCompatibleSettings>,
20    pub bedrock: AmazonBedrockSettings,
21    pub deepseek: DeepSeekSettings,
22    pub google: GoogleSettings,
23    pub llama_cpp: LlamaCppSettings,
24    pub lmstudio: LmStudioSettings,
25    pub mistral: MistralSettings,
26    pub ollama: OllamaSettings,
27    pub opencode: OpenCodeSettings,
28    pub open_router: OpenRouterSettings,
29    pub openai: OpenAiSettings,
30    pub openai_compatible: HashMap<Arc<str>, OpenAiCompatibleSettings>,
31    pub vercel_ai_gateway: VercelAiGatewaySettings,
32    pub x_ai: XAiSettings,
33    pub zed_dot_dev: ZedDotDevSettings,
34}
35
36fn custom_headers_from(
37    provider_name: &str,
38    raw: Option<HashMap<String, String>>,
39    reserved: &[&str],
40) -> http_client::CustomHeaders {
41    raw.as_ref()
42        .filter(|map| !map.is_empty())
43        .map(|map| resolve_custom_headers(provider_name, map, reserved))
44        .unwrap_or_default()
45}
46
47impl settings::Settings for AllLanguageModelSettings {
48    const PRESERVED_KEYS: Option<&'static [&'static str]> = Some(&["version"]);
49
50    fn from_settings(content: &settings::SettingsContent) -> Self {
51        let language_models = content.language_models.clone().unwrap();
52        let anthropic = language_models.anthropic.unwrap();
53        let anthropic_compatible = language_models.anthropic_compatible.unwrap();
54        let bedrock = language_models.bedrock.unwrap();
55        let deepseek = language_models.deepseek.unwrap();
56        let google = language_models.google.unwrap();
57        let llama_cpp = language_models.llama_cpp.unwrap();
58        let lmstudio = language_models.lmstudio.unwrap();
59        let mistral = language_models.mistral.unwrap();
60        let ollama = language_models.ollama.unwrap();
61        let opencode = language_models.opencode.unwrap();
62        let open_router = language_models.open_router.unwrap();
63        let openai = language_models.openai.unwrap();
64        let openai_compatible = language_models.openai_compatible.unwrap();
65        let vercel_ai_gateway = language_models.vercel_ai_gateway.unwrap();
66        let x_ai = language_models.x_ai.unwrap();
67        let zed_dot_dev = language_models.zed_dot_dev.unwrap();
68        Self {
69            anthropic: AnthropicSettings {
70                api_url: anthropic.api_url.unwrap(),
71                available_models: anthropic.available_models.unwrap_or_default(),
72                custom_headers: custom_headers_from(
73                    "Anthropic",
74                    anthropic.custom_headers,
75                    anthropic::RESERVED_HEADER_NAMES,
76                ),
77            },
78            anthropic_compatible: anthropic_compatible
79                .into_iter()
80                .map(|(key, value)| {
81                    let provider_label = format!("Anthropic Compatible ({key})");
82                    (
83                        key,
84                        AnthropicCompatibleSettings {
85                            api_url: value.api_url,
86                            available_models: value.available_models,
87                            custom_headers: custom_headers_from(
88                                &provider_label,
89                                value.custom_headers,
90                                anthropic::RESERVED_HEADER_NAMES,
91                            ),
92                        },
93                    )
94                })
95                .collect(),
96            bedrock: AmazonBedrockSettings {
97                available_models: bedrock.available_models.unwrap_or_default(),
98                mantle_available_models: bedrock.mantle_available_models.unwrap_or_default(),
99                custom_headers: custom_headers_from(
100                    "Amazon Bedrock",
101                    bedrock.custom_headers,
102                    bedrock::RESERVED_HEADER_NAMES,
103                ),
104                region: bedrock.region,
105                endpoint: bedrock.endpoint_url, // todo(should be api_url)
106                profile_name: bedrock.profile,
107                role_arn: None, // todo(was never a setting for this...)
108                authentication_method: bedrock.authentication_method.map(Into::into),
109                allow_global: bedrock.allow_global,
110                guardrail_identifier: bedrock.guardrail_identifier,
111                guardrail_version: bedrock.guardrail_version,
112            },
113            deepseek: DeepSeekSettings {
114                api_url: deepseek.api_url.unwrap(),
115                available_models: deepseek.available_models.unwrap_or_default(),
116                custom_headers: custom_headers_from("DeepSeek", deepseek.custom_headers, &[]),
117            },
118            google: GoogleSettings {
119                api_url: google.api_url.unwrap(),
120                available_models: google.available_models.unwrap_or_default(),
121                custom_headers: custom_headers_from("Google AI", google.custom_headers, &[]),
122            },
123            llama_cpp: LlamaCppSettings {
124                api_url: llama_cpp.api_url.unwrap(),
125                auto_discover: llama_cpp.auto_discover.unwrap_or(true),
126                available_models: llama_cpp.available_models.unwrap_or_default(),
127                context_window: llama_cpp.context_window,
128                custom_headers: custom_headers_from("llama.cpp", llama_cpp.custom_headers, &[]),
129            },
130            lmstudio: LmStudioSettings {
131                api_url: lmstudio.api_url.unwrap(),
132                available_models: lmstudio.available_models.unwrap_or_default(),
133                custom_headers: custom_headers_from("LM Studio", lmstudio.custom_headers, &[]),
134            },
135            mistral: MistralSettings {
136                api_url: mistral.api_url.unwrap(),
137                available_models: mistral.available_models.unwrap_or_default(),
138                custom_headers: custom_headers_from(
139                    "Mistral",
140                    mistral.custom_headers,
141                    mistral::RESERVED_HEADER_NAMES,
142                ),
143            },
144            ollama: OllamaSettings {
145                api_url: ollama.api_url.unwrap(),
146                auto_discover: ollama.auto_discover.unwrap_or(true),
147                available_models: ollama.available_models.unwrap_or_default(),
148                context_window: ollama.context_window,
149                custom_headers: custom_headers_from("Ollama", ollama.custom_headers, &[]),
150            },
151            opencode: OpenCodeSettings {
152                api_url: opencode.api_url.unwrap(),
153                available_models: opencode.available_models.unwrap_or_default(),
154                custom_headers: custom_headers_from(
155                    "OpenCode",
156                    opencode.custom_headers,
157                    opencode::RESERVED_HEADER_NAMES,
158                ),
159                show_zen_models: opencode.show_zen_models.unwrap_or(true),
160                show_go_models: opencode.show_go_models.unwrap_or(true),
161                show_free_models: opencode.show_free_models.unwrap_or(true),
162            },
163            open_router: OpenRouterSettings {
164                api_url: open_router.api_url.unwrap(),
165                available_models: open_router.available_models.unwrap_or_default(),
166                custom_headers: custom_headers_from(
167                    "OpenRouter",
168                    open_router.custom_headers,
169                    open_router::RESERVED_HEADER_NAMES,
170                ),
171            },
172            openai: OpenAiSettings {
173                api_url: openai.api_url.unwrap(),
174                available_models: openai.available_models.unwrap_or_default(),
175                custom_headers: custom_headers_from("OpenAI", openai.custom_headers, &[]),
176            },
177            openai_compatible: openai_compatible
178                .into_iter()
179                .map(|(key, value)| {
180                    let provider_label = format!("OpenAI Compatible ({key})");
181                    (
182                        key,
183                        OpenAiCompatibleSettings {
184                            api_url: value.api_url,
185                            available_models: value.available_models,
186                            custom_headers: custom_headers_from(
187                                &provider_label,
188                                value.custom_headers,
189                                &[],
190                            ),
191                        },
192                    )
193                })
194                .collect(),
195            vercel_ai_gateway: VercelAiGatewaySettings {
196                api_url: vercel_ai_gateway.api_url.unwrap(),
197                available_models: vercel_ai_gateway.available_models.unwrap_or_default(),
198                custom_headers: custom_headers_from(
199                    "Vercel AI Gateway",
200                    vercel_ai_gateway.custom_headers,
201                    &[],
202                ),
203            },
204            x_ai: XAiSettings {
205                api_url: x_ai.api_url.unwrap(),
206                available_models: x_ai.available_models.unwrap_or_default(),
207                custom_headers: custom_headers_from("xAI", x_ai.custom_headers, &[]),
208            },
209            zed_dot_dev: ZedDotDevSettings {
210                available_models: zed_dot_dev.available_models.unwrap_or_default(),
211            },
212        }
213    }
214}
215