1use std::sync::Arc;
2
3use ::open_ai::Model as OpenAiModel;
4use anthropic::Model as AnthropicModel;
5use fs::Fs;
6use gpui::{AppContext, Pixels};
7use language_model::provider::open_ai;
8use language_model::settings::{
9 AnthropicSettingsContent, AnthropicSettingsContentV1, OllamaSettingsContent,
10 OpenAiSettingsContent, OpenAiSettingsContentV1, VersionedAnthropicSettingsContent,
11 VersionedOpenAiSettingsContent,
12};
13use language_model::{settings::AllLanguageModelSettings, CloudModel, LanguageModel};
14use ollama::Model as OllamaModel;
15use schemars::{schema::Schema, JsonSchema};
16use serde::{Deserialize, Serialize};
17use settings::{update_settings_file, Settings, SettingsSources};
18
19#[derive(Copy, Clone, Default, Debug, Serialize, Deserialize, JsonSchema)]
20#[serde(rename_all = "snake_case")]
21pub enum AssistantDockPosition {
22 Left,
23 #[default]
24 Right,
25 Bottom,
26}
27
28#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq)]
29#[serde(tag = "name", rename_all = "snake_case")]
30pub enum AssistantProviderContentV1 {
31 #[serde(rename = "zed.dev")]
32 ZedDotDev { default_model: Option<CloudModel> },
33 #[serde(rename = "openai")]
34 OpenAi {
35 default_model: Option<OpenAiModel>,
36 api_url: Option<String>,
37 low_speed_timeout_in_seconds: Option<u64>,
38 available_models: Option<Vec<OpenAiModel>>,
39 },
40 #[serde(rename = "anthropic")]
41 Anthropic {
42 default_model: Option<AnthropicModel>,
43 api_url: Option<String>,
44 low_speed_timeout_in_seconds: Option<u64>,
45 },
46 #[serde(rename = "ollama")]
47 Ollama {
48 default_model: Option<OllamaModel>,
49 api_url: Option<String>,
50 low_speed_timeout_in_seconds: Option<u64>,
51 },
52}
53
54#[derive(Debug, Default)]
55pub struct AssistantSettings {
56 pub enabled: bool,
57 pub button: bool,
58 pub dock: AssistantDockPosition,
59 pub default_width: Pixels,
60 pub default_height: Pixels,
61 pub default_model: LanguageModelSelection,
62 pub using_outdated_settings_version: bool,
63}
64
65/// Assistant panel settings
66#[derive(Clone, Serialize, Deserialize, Debug)]
67#[serde(untagged)]
68pub enum AssistantSettingsContent {
69 Versioned(VersionedAssistantSettingsContent),
70 Legacy(LegacyAssistantSettingsContent),
71}
72
73impl JsonSchema for AssistantSettingsContent {
74 fn schema_name() -> String {
75 VersionedAssistantSettingsContent::schema_name()
76 }
77
78 fn json_schema(gen: &mut schemars::gen::SchemaGenerator) -> Schema {
79 VersionedAssistantSettingsContent::json_schema(gen)
80 }
81
82 fn is_referenceable() -> bool {
83 VersionedAssistantSettingsContent::is_referenceable()
84 }
85}
86
87impl Default for AssistantSettingsContent {
88 fn default() -> Self {
89 Self::Versioned(VersionedAssistantSettingsContent::default())
90 }
91}
92
93impl AssistantSettingsContent {
94 pub fn is_version_outdated(&self) -> bool {
95 match self {
96 AssistantSettingsContent::Versioned(settings) => match settings {
97 VersionedAssistantSettingsContent::V1(_) => true,
98 VersionedAssistantSettingsContent::V2(_) => false,
99 },
100 AssistantSettingsContent::Legacy(_) => true,
101 }
102 }
103
104 pub fn update_file(&mut self, fs: Arc<dyn Fs>, cx: &AppContext) {
105 if let AssistantSettingsContent::Versioned(settings) = self {
106 if let VersionedAssistantSettingsContent::V1(settings) = settings {
107 if let Some(provider) = settings.provider.clone() {
108 match provider {
109 AssistantProviderContentV1::Anthropic {
110 api_url,
111 low_speed_timeout_in_seconds,
112 ..
113 } => update_settings_file::<AllLanguageModelSettings>(
114 fs,
115 cx,
116 move |content, _| {
117 if content.anthropic.is_none() {
118 content.anthropic = Some(AnthropicSettingsContent::Versioned(
119 VersionedAnthropicSettingsContent::V1(
120 AnthropicSettingsContentV1 {
121 api_url,
122 low_speed_timeout_in_seconds,
123 available_models: None,
124 },
125 ),
126 ));
127 }
128 },
129 ),
130 AssistantProviderContentV1::Ollama {
131 api_url,
132 low_speed_timeout_in_seconds,
133 ..
134 } => update_settings_file::<AllLanguageModelSettings>(
135 fs,
136 cx,
137 move |content, _| {
138 if content.ollama.is_none() {
139 content.ollama = Some(OllamaSettingsContent {
140 api_url,
141 low_speed_timeout_in_seconds,
142 available_models: None,
143 });
144 }
145 },
146 ),
147 AssistantProviderContentV1::OpenAi {
148 api_url,
149 low_speed_timeout_in_seconds,
150 available_models,
151 ..
152 } => update_settings_file::<AllLanguageModelSettings>(
153 fs,
154 cx,
155 move |content, _| {
156 if content.openai.is_none() {
157 let available_models = available_models.map(|models| {
158 models
159 .into_iter()
160 .filter_map(|model| match model {
161 OpenAiModel::Custom {
162 name,
163 max_tokens,
164 max_output_tokens,
165 } => Some(open_ai::AvailableModel {
166 name,
167 max_tokens,
168 max_output_tokens,
169 }),
170 _ => None,
171 })
172 .collect::<Vec<_>>()
173 });
174 content.openai = Some(OpenAiSettingsContent::Versioned(
175 VersionedOpenAiSettingsContent::V1(
176 OpenAiSettingsContentV1 {
177 api_url,
178 low_speed_timeout_in_seconds,
179 available_models,
180 },
181 ),
182 ));
183 }
184 },
185 ),
186 _ => {}
187 }
188 }
189 }
190 }
191
192 *self = AssistantSettingsContent::Versioned(VersionedAssistantSettingsContent::V2(
193 self.upgrade(),
194 ));
195 }
196
197 fn upgrade(&self) -> AssistantSettingsContentV2 {
198 match self {
199 AssistantSettingsContent::Versioned(settings) => match settings {
200 VersionedAssistantSettingsContent::V1(settings) => AssistantSettingsContentV2 {
201 enabled: settings.enabled,
202 button: settings.button,
203 dock: settings.dock,
204 default_width: settings.default_width,
205 default_height: settings.default_width,
206 default_model: settings
207 .provider
208 .clone()
209 .and_then(|provider| match provider {
210 AssistantProviderContentV1::ZedDotDev { default_model } => {
211 default_model.map(|model| LanguageModelSelection {
212 provider: "zed.dev".to_string(),
213 model: model.id().to_string(),
214 })
215 }
216 AssistantProviderContentV1::OpenAi { default_model, .. } => {
217 default_model.map(|model| LanguageModelSelection {
218 provider: "openai".to_string(),
219 model: model.id().to_string(),
220 })
221 }
222 AssistantProviderContentV1::Anthropic { default_model, .. } => {
223 default_model.map(|model| LanguageModelSelection {
224 provider: "anthropic".to_string(),
225 model: model.id().to_string(),
226 })
227 }
228 AssistantProviderContentV1::Ollama { default_model, .. } => {
229 default_model.map(|model| LanguageModelSelection {
230 provider: "ollama".to_string(),
231 model: model.id().to_string(),
232 })
233 }
234 }),
235 },
236 VersionedAssistantSettingsContent::V2(settings) => settings.clone(),
237 },
238 AssistantSettingsContent::Legacy(settings) => AssistantSettingsContentV2 {
239 enabled: None,
240 button: settings.button,
241 dock: settings.dock,
242 default_width: settings.default_width,
243 default_height: settings.default_height,
244 default_model: Some(LanguageModelSelection {
245 provider: "openai".to_string(),
246 model: settings
247 .default_open_ai_model
248 .clone()
249 .unwrap_or_default()
250 .id()
251 .to_string(),
252 }),
253 },
254 }
255 }
256
257 pub fn set_dock(&mut self, dock: AssistantDockPosition) {
258 match self {
259 AssistantSettingsContent::Versioned(settings) => match settings {
260 VersionedAssistantSettingsContent::V1(settings) => {
261 settings.dock = Some(dock);
262 }
263 VersionedAssistantSettingsContent::V2(settings) => {
264 settings.dock = Some(dock);
265 }
266 },
267 AssistantSettingsContent::Legacy(settings) => {
268 settings.dock = Some(dock);
269 }
270 }
271 }
272
273 pub fn set_model(&mut self, language_model: Arc<dyn LanguageModel>) {
274 let model = language_model.id().0.to_string();
275 let provider = language_model.provider_id().0.to_string();
276
277 match self {
278 AssistantSettingsContent::Versioned(settings) => match settings {
279 VersionedAssistantSettingsContent::V1(settings) => match provider.as_ref() {
280 "zed.dev" => {
281 log::warn!("attempted to set zed.dev model on outdated settings");
282 }
283 "anthropic" => {
284 let (api_url, low_speed_timeout_in_seconds) = match &settings.provider {
285 Some(AssistantProviderContentV1::Anthropic {
286 api_url,
287 low_speed_timeout_in_seconds,
288 ..
289 }) => (api_url.clone(), *low_speed_timeout_in_seconds),
290 _ => (None, None),
291 };
292 settings.provider = Some(AssistantProviderContentV1::Anthropic {
293 default_model: AnthropicModel::from_id(&model).ok(),
294 api_url,
295 low_speed_timeout_in_seconds,
296 });
297 }
298 "ollama" => {
299 let (api_url, low_speed_timeout_in_seconds) = match &settings.provider {
300 Some(AssistantProviderContentV1::Ollama {
301 api_url,
302 low_speed_timeout_in_seconds,
303 ..
304 }) => (api_url.clone(), *low_speed_timeout_in_seconds),
305 _ => (None, None),
306 };
307 settings.provider = Some(AssistantProviderContentV1::Ollama {
308 default_model: Some(ollama::Model::new(&model, None, None)),
309 api_url,
310 low_speed_timeout_in_seconds,
311 });
312 }
313 "openai" => {
314 let (api_url, low_speed_timeout_in_seconds, available_models) =
315 match &settings.provider {
316 Some(AssistantProviderContentV1::OpenAi {
317 api_url,
318 low_speed_timeout_in_seconds,
319 available_models,
320 ..
321 }) => (
322 api_url.clone(),
323 *low_speed_timeout_in_seconds,
324 available_models.clone(),
325 ),
326 _ => (None, None, None),
327 };
328 settings.provider = Some(AssistantProviderContentV1::OpenAi {
329 default_model: OpenAiModel::from_id(&model).ok(),
330 api_url,
331 low_speed_timeout_in_seconds,
332 available_models,
333 });
334 }
335 _ => {}
336 },
337 VersionedAssistantSettingsContent::V2(settings) => {
338 settings.default_model = Some(LanguageModelSelection { provider, model });
339 }
340 },
341 AssistantSettingsContent::Legacy(settings) => {
342 if let Ok(model) = OpenAiModel::from_id(&language_model.id().0) {
343 settings.default_open_ai_model = Some(model);
344 }
345 }
346 }
347 }
348}
349
350#[derive(Clone, Serialize, Deserialize, JsonSchema, Debug)]
351#[serde(tag = "version")]
352pub enum VersionedAssistantSettingsContent {
353 #[serde(rename = "1")]
354 V1(AssistantSettingsContentV1),
355 #[serde(rename = "2")]
356 V2(AssistantSettingsContentV2),
357}
358
359impl Default for VersionedAssistantSettingsContent {
360 fn default() -> Self {
361 Self::V2(AssistantSettingsContentV2 {
362 enabled: None,
363 button: None,
364 dock: None,
365 default_width: None,
366 default_height: None,
367 default_model: None,
368 })
369 }
370}
371
372#[derive(Clone, Serialize, Deserialize, JsonSchema, Debug)]
373pub struct AssistantSettingsContentV2 {
374 /// Whether the Assistant is enabled.
375 ///
376 /// Default: true
377 enabled: Option<bool>,
378 /// Whether to show the assistant panel button in the status bar.
379 ///
380 /// Default: true
381 button: Option<bool>,
382 /// Where to dock the assistant.
383 ///
384 /// Default: right
385 dock: Option<AssistantDockPosition>,
386 /// Default width in pixels when the assistant is docked to the left or right.
387 ///
388 /// Default: 640
389 default_width: Option<f32>,
390 /// Default height in pixels when the assistant is docked to the bottom.
391 ///
392 /// Default: 320
393 default_height: Option<f32>,
394 /// The default model to use when creating new contexts.
395 default_model: Option<LanguageModelSelection>,
396}
397
398#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq)]
399pub struct LanguageModelSelection {
400 #[schemars(schema_with = "providers_schema")]
401 pub provider: String,
402 pub model: String,
403}
404
405fn providers_schema(_: &mut schemars::gen::SchemaGenerator) -> schemars::schema::Schema {
406 schemars::schema::SchemaObject {
407 enum_values: Some(vec![
408 "anthropic".into(),
409 "google".into(),
410 "ollama".into(),
411 "openai".into(),
412 "zed.dev".into(),
413 "copilot_chat".into(),
414 ]),
415 ..Default::default()
416 }
417 .into()
418}
419
420impl Default for LanguageModelSelection {
421 fn default() -> Self {
422 Self {
423 provider: "openai".to_string(),
424 model: "gpt-4".to_string(),
425 }
426 }
427}
428
429#[derive(Clone, Serialize, Deserialize, JsonSchema, Debug)]
430pub struct AssistantSettingsContentV1 {
431 /// Whether the Assistant is enabled.
432 ///
433 /// Default: true
434 enabled: Option<bool>,
435 /// Whether to show the assistant panel button in the status bar.
436 ///
437 /// Default: true
438 button: Option<bool>,
439 /// Where to dock the assistant.
440 ///
441 /// Default: right
442 dock: Option<AssistantDockPosition>,
443 /// Default width in pixels when the assistant is docked to the left or right.
444 ///
445 /// Default: 640
446 default_width: Option<f32>,
447 /// Default height in pixels when the assistant is docked to the bottom.
448 ///
449 /// Default: 320
450 default_height: Option<f32>,
451 /// The provider of the assistant service.
452 ///
453 /// This can be "openai", "anthropic", "ollama", "zed.dev"
454 /// each with their respective default models and configurations.
455 provider: Option<AssistantProviderContentV1>,
456}
457
458#[derive(Clone, Serialize, Deserialize, JsonSchema, Debug)]
459pub struct LegacyAssistantSettingsContent {
460 /// Whether to show the assistant panel button in the status bar.
461 ///
462 /// Default: true
463 pub button: Option<bool>,
464 /// Where to dock the assistant.
465 ///
466 /// Default: right
467 pub dock: Option<AssistantDockPosition>,
468 /// Default width in pixels when the assistant is docked to the left or right.
469 ///
470 /// Default: 640
471 pub default_width: Option<f32>,
472 /// Default height in pixels when the assistant is docked to the bottom.
473 ///
474 /// Default: 320
475 pub default_height: Option<f32>,
476 /// The default OpenAI model to use when creating new contexts.
477 ///
478 /// Default: gpt-4-1106-preview
479 pub default_open_ai_model: Option<OpenAiModel>,
480 /// OpenAI API base URL to use when creating new contexts.
481 ///
482 /// Default: https://api.openai.com/v1
483 pub openai_api_url: Option<String>,
484}
485
486impl Settings for AssistantSettings {
487 const KEY: Option<&'static str> = Some("assistant");
488
489 const PRESERVED_KEYS: Option<&'static [&'static str]> = Some(&["version"]);
490
491 type FileContent = AssistantSettingsContent;
492
493 fn load(
494 sources: SettingsSources<Self::FileContent>,
495 _: &mut gpui::AppContext,
496 ) -> anyhow::Result<Self> {
497 let mut settings = AssistantSettings::default();
498
499 for value in sources.defaults_and_customizations() {
500 if value.is_version_outdated() {
501 settings.using_outdated_settings_version = true;
502 }
503
504 let value = value.upgrade();
505 merge(&mut settings.enabled, value.enabled);
506 merge(&mut settings.button, value.button);
507 merge(&mut settings.dock, value.dock);
508 merge(
509 &mut settings.default_width,
510 value.default_width.map(Into::into),
511 );
512 merge(
513 &mut settings.default_height,
514 value.default_height.map(Into::into),
515 );
516 merge(
517 &mut settings.default_model,
518 value.default_model.map(Into::into),
519 );
520 }
521
522 Ok(settings)
523 }
524}
525
526fn merge<T>(target: &mut T, value: Option<T>) {
527 if let Some(value) = value {
528 *target = value;
529 }
530}
531
532#[cfg(test)]
533mod tests {
534 use gpui::{ReadGlobal, TestAppContext};
535
536 use super::*;
537
538 #[gpui::test]
539 async fn test_deserialize_assistant_settings_with_version(cx: &mut TestAppContext) {
540 let fs = fs::FakeFs::new(cx.executor().clone());
541 fs.create_dir(paths::settings_file().parent().unwrap())
542 .await
543 .unwrap();
544
545 cx.update(|cx| {
546 let test_settings = settings::SettingsStore::test(cx);
547 cx.set_global(test_settings);
548 AssistantSettings::register(cx);
549 });
550
551 cx.update(|cx| {
552 assert!(!AssistantSettings::get_global(cx).using_outdated_settings_version);
553 assert_eq!(
554 AssistantSettings::get_global(cx).default_model,
555 LanguageModelSelection {
556 provider: "zed.dev".into(),
557 model: "claude-3-5-sonnet".into(),
558 }
559 );
560 });
561
562 cx.update(|cx| {
563 settings::SettingsStore::global(cx).update_settings_file::<AssistantSettings>(
564 fs.clone(),
565 |settings, _| {
566 *settings = AssistantSettingsContent::Versioned(
567 VersionedAssistantSettingsContent::V2(AssistantSettingsContentV2 {
568 default_model: Some(LanguageModelSelection {
569 provider: "test-provider".into(),
570 model: "gpt-99".into(),
571 }),
572 enabled: None,
573 button: None,
574 dock: None,
575 default_width: None,
576 default_height: None,
577 }),
578 )
579 },
580 );
581 });
582
583 cx.run_until_parked();
584
585 let raw_settings_value = fs.load(paths::settings_file()).await.unwrap();
586 assert!(raw_settings_value.contains(r#""version": "2""#));
587
588 #[derive(Debug, Deserialize)]
589 struct AssistantSettingsTest {
590 assistant: AssistantSettingsContent,
591 }
592
593 let assistant_settings: AssistantSettingsTest =
594 serde_json_lenient::from_str(&raw_settings_value).unwrap();
595
596 assert!(!assistant_settings.assistant.is_version_outdated());
597 }
598}