1mod agent_profile;
2
3use std::sync::Arc;
4
5use collections::IndexMap;
6use gpui::{App, Pixels, px};
7use language_model::LanguageModel;
8use schemars::JsonSchema;
9use serde::{Deserialize, Serialize};
10use settings::{
11 DefaultAgentView, DockPosition, LanguageModelParameters, LanguageModelSelection,
12 NotifyWhenAgentWaiting, Settings, SettingsContent,
13};
14
15pub use crate::agent_profile::*;
16
17pub const SUMMARIZE_THREAD_PROMPT: &str =
18 include_str!("../../agent/src/prompts/summarize_thread_prompt.txt");
19pub const SUMMARIZE_THREAD_DETAILED_PROMPT: &str =
20 include_str!("../../agent/src/prompts/summarize_thread_detailed_prompt.txt");
21
22pub fn init(cx: &mut App) {
23 AgentSettings::register(cx);
24}
25
26#[derive(Clone, Debug)]
27pub struct AgentSettings {
28 pub enabled: bool,
29 pub button: bool,
30 pub dock: DockPosition,
31 pub default_width: Pixels,
32 pub default_height: Pixels,
33 pub default_model: Option<LanguageModelSelection>,
34 pub inline_assistant_model: Option<LanguageModelSelection>,
35 pub commit_message_model: Option<LanguageModelSelection>,
36 pub thread_summary_model: Option<LanguageModelSelection>,
37 pub inline_alternatives: Vec<LanguageModelSelection>,
38 pub default_profile: AgentProfileId,
39 pub default_view: DefaultAgentView,
40 pub profiles: IndexMap<AgentProfileId, AgentProfileSettings>,
41 pub always_allow_tool_actions: bool,
42 pub notify_when_agent_waiting: NotifyWhenAgentWaiting,
43 pub play_sound_when_agent_done: bool,
44 pub stream_edits: bool,
45 pub single_file_review: bool,
46 pub model_parameters: Vec<LanguageModelParameters>,
47 pub preferred_completion_mode: CompletionMode,
48 pub enable_feedback: bool,
49 pub expand_edit_card: bool,
50 pub expand_terminal_card: bool,
51 pub use_modifier_to_send: bool,
52 pub message_editor_min_lines: usize,
53}
54
55impl AgentSettings {
56 pub fn temperature_for_model(model: &Arc<dyn LanguageModel>, cx: &App) -> Option<f32> {
57 let settings = Self::get_global(cx);
58 for setting in settings.model_parameters.iter().rev() {
59 if let Some(provider) = &setting.provider
60 && provider.0 != model.provider_id().0
61 {
62 continue;
63 }
64 if let Some(setting_model) = &setting.model
65 && *setting_model != model.id().0
66 {
67 continue;
68 }
69 return setting.temperature;
70 }
71 return None;
72 }
73
74 pub fn set_inline_assistant_model(&mut self, provider: String, model: String) {
75 self.inline_assistant_model = Some(LanguageModelSelection {
76 provider: provider.into(),
77 model,
78 });
79 }
80
81 pub fn set_commit_message_model(&mut self, provider: String, model: String) {
82 self.commit_message_model = Some(LanguageModelSelection {
83 provider: provider.into(),
84 model,
85 });
86 }
87
88 pub fn set_thread_summary_model(&mut self, provider: String, model: String) {
89 self.thread_summary_model = Some(LanguageModelSelection {
90 provider: provider.into(),
91 model,
92 });
93 }
94
95 pub fn set_message_editor_max_lines(&self) -> usize {
96 self.message_editor_min_lines * 2
97 }
98}
99
100#[derive(Clone, Copy, Debug, Serialize, Deserialize, JsonSchema, PartialEq, Default)]
101#[serde(rename_all = "snake_case")]
102pub enum CompletionMode {
103 #[default]
104 Normal,
105 #[serde(alias = "max")]
106 Burn,
107}
108
109impl From<CompletionMode> for cloud_llm_client::CompletionMode {
110 fn from(value: CompletionMode) -> Self {
111 match value {
112 CompletionMode::Normal => cloud_llm_client::CompletionMode::Normal,
113 CompletionMode::Burn => cloud_llm_client::CompletionMode::Max,
114 }
115 }
116}
117
118impl From<settings::CompletionMode> for CompletionMode {
119 fn from(value: settings::CompletionMode) -> Self {
120 match value {
121 settings::CompletionMode::Normal => CompletionMode::Normal,
122 settings::CompletionMode::Burn => CompletionMode::Burn,
123 }
124 }
125}
126
127#[derive(Debug, PartialEq, Eq, Hash, Clone, Serialize, Deserialize, JsonSchema)]
128pub struct AgentProfileId(pub Arc<str>);
129
130impl AgentProfileId {
131 pub fn as_str(&self) -> &str {
132 &self.0
133 }
134}
135
136impl std::fmt::Display for AgentProfileId {
137 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
138 write!(f, "{}", self.0)
139 }
140}
141
142impl Default for AgentProfileId {
143 fn default() -> Self {
144 Self("write".into())
145 }
146}
147
148impl Settings for AgentSettings {
149 fn from_settings(content: &settings::SettingsContent, _cx: &mut App) -> Self {
150 let agent = content.agent.clone().unwrap();
151 Self {
152 enabled: agent.enabled.unwrap(),
153 button: agent.button.unwrap(),
154 dock: agent.dock.unwrap(),
155 default_width: px(agent.default_width.unwrap()),
156 default_height: px(agent.default_height.unwrap()),
157 default_model: Some(agent.default_model.unwrap()),
158 inline_assistant_model: agent.inline_assistant_model,
159 commit_message_model: agent.commit_message_model,
160 thread_summary_model: agent.thread_summary_model,
161 inline_alternatives: agent.inline_alternatives.unwrap_or_default(),
162 default_profile: AgentProfileId(agent.default_profile.unwrap()),
163 default_view: agent.default_view.unwrap(),
164 profiles: agent
165 .profiles
166 .unwrap()
167 .into_iter()
168 .map(|(key, val)| (AgentProfileId(key), val.into()))
169 .collect(),
170 always_allow_tool_actions: agent.always_allow_tool_actions.unwrap(),
171 notify_when_agent_waiting: agent.notify_when_agent_waiting.unwrap(),
172 play_sound_when_agent_done: agent.play_sound_when_agent_done.unwrap(),
173 stream_edits: agent.stream_edits.unwrap(),
174 single_file_review: agent.single_file_review.unwrap(),
175 model_parameters: agent.model_parameters,
176 preferred_completion_mode: agent.preferred_completion_mode.unwrap().into(),
177 enable_feedback: agent.enable_feedback.unwrap(),
178 expand_edit_card: agent.expand_edit_card.unwrap(),
179 expand_terminal_card: agent.expand_terminal_card.unwrap(),
180 use_modifier_to_send: agent.use_modifier_to_send.unwrap(),
181 message_editor_min_lines: agent.message_editor_min_lines.unwrap(),
182 }
183 }
184
185 fn import_from_vscode(vscode: &settings::VsCodeSettings, current: &mut SettingsContent) {
186 if let Some(b) = vscode
187 .read_value("chat.agent.enabled")
188 .and_then(|b| b.as_bool())
189 {
190 current.agent.get_or_insert_default().enabled = Some(b);
191 current.agent.get_or_insert_default().button = Some(b);
192 }
193 }
194}