1mod ambient_context;
2pub mod assistant_panel;
3pub mod assistant_settings;
4mod codegen;
5mod completion_provider;
6mod omit_ranges;
7mod prompts;
8mod saved_conversation;
9mod search;
10mod slash_command;
11mod streaming_diff;
12
13use ambient_context::AmbientContextSnapshot;
14pub use assistant_panel::AssistantPanel;
15use assistant_settings::{AnthropicModel, AssistantSettings, OpenAiModel, ZedDotDevModel};
16use client::{proto, Client};
17use command_palette_hooks::CommandPaletteFilter;
18pub(crate) use completion_provider::*;
19use gpui::{actions, AppContext, Global, SharedString, UpdateGlobal};
20pub(crate) use saved_conversation::*;
21use serde::{Deserialize, Serialize};
22use settings::{Settings, SettingsStore};
23use std::{
24 fmt::{self, Display},
25 sync::Arc,
26};
27
28actions!(
29 assistant,
30 [
31 Assist,
32 Split,
33 CycleMessageRole,
34 QuoteSelection,
35 ToggleFocus,
36 ResetKey,
37 InlineAssist,
38 InsertActivePrompt,
39 ToggleIncludeConversation,
40 ToggleHistory,
41 ApplyEdit
42 ]
43);
44
45#[derive(
46 Copy, Clone, Debug, Default, Eq, PartialEq, PartialOrd, Ord, Hash, Serialize, Deserialize,
47)]
48struct MessageId(usize);
49
50#[derive(Clone, Copy, Serialize, Deserialize, Debug, Eq, PartialEq)]
51#[serde(rename_all = "lowercase")]
52pub enum Role {
53 User,
54 Assistant,
55 System,
56}
57
58impl Role {
59 pub fn cycle(&mut self) {
60 *self = match self {
61 Role::User => Role::Assistant,
62 Role::Assistant => Role::System,
63 Role::System => Role::User,
64 }
65 }
66}
67
68impl Display for Role {
69 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> std::fmt::Result {
70 match self {
71 Role::User => write!(f, "user"),
72 Role::Assistant => write!(f, "assistant"),
73 Role::System => write!(f, "system"),
74 }
75 }
76}
77
78#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
79pub enum LanguageModel {
80 ZedDotDev(ZedDotDevModel),
81 OpenAi(OpenAiModel),
82 Anthropic(AnthropicModel),
83}
84
85impl Default for LanguageModel {
86 fn default() -> Self {
87 LanguageModel::ZedDotDev(ZedDotDevModel::default())
88 }
89}
90
91impl LanguageModel {
92 pub fn telemetry_id(&self) -> String {
93 match self {
94 LanguageModel::OpenAi(model) => format!("openai/{}", model.id()),
95 LanguageModel::Anthropic(model) => format!("anthropic/{}", model.id()),
96 LanguageModel::ZedDotDev(model) => format!("zed.dev/{}", model.id()),
97 }
98 }
99
100 pub fn display_name(&self) -> String {
101 match self {
102 LanguageModel::OpenAi(model) => model.display_name().into(),
103 LanguageModel::Anthropic(model) => model.display_name().into(),
104 LanguageModel::ZedDotDev(model) => model.display_name().into(),
105 }
106 }
107
108 pub fn max_token_count(&self) -> usize {
109 match self {
110 LanguageModel::OpenAi(model) => model.max_token_count(),
111 LanguageModel::Anthropic(model) => model.max_token_count(),
112 LanguageModel::ZedDotDev(model) => model.max_token_count(),
113 }
114 }
115
116 pub fn id(&self) -> &str {
117 match self {
118 LanguageModel::OpenAi(model) => model.id(),
119 LanguageModel::Anthropic(model) => model.id(),
120 LanguageModel::ZedDotDev(model) => model.id(),
121 }
122 }
123}
124
125#[derive(Serialize, Deserialize, Debug, Eq, PartialEq)]
126pub struct LanguageModelRequestMessage {
127 pub role: Role,
128 pub content: String,
129}
130
131impl LanguageModelRequestMessage {
132 pub fn to_proto(&self) -> proto::LanguageModelRequestMessage {
133 proto::LanguageModelRequestMessage {
134 role: match self.role {
135 Role::User => proto::LanguageModelRole::LanguageModelUser,
136 Role::Assistant => proto::LanguageModelRole::LanguageModelAssistant,
137 Role::System => proto::LanguageModelRole::LanguageModelSystem,
138 } as i32,
139 content: self.content.clone(),
140 tool_calls: Vec::new(),
141 tool_call_id: None,
142 }
143 }
144}
145
146#[derive(Debug, Default, Serialize)]
147pub struct LanguageModelRequest {
148 pub model: LanguageModel,
149 pub messages: Vec<LanguageModelRequestMessage>,
150 pub stop: Vec<String>,
151 pub temperature: f32,
152}
153
154impl LanguageModelRequest {
155 pub fn to_proto(&self) -> proto::CompleteWithLanguageModel {
156 proto::CompleteWithLanguageModel {
157 model: self.model.id().to_string(),
158 messages: self.messages.iter().map(|m| m.to_proto()).collect(),
159 stop: self.stop.clone(),
160 temperature: self.temperature,
161 tool_choice: None,
162 tools: Vec::new(),
163 }
164 }
165}
166
167#[derive(Serialize, Deserialize, Debug, Eq, PartialEq)]
168pub struct LanguageModelResponseMessage {
169 pub role: Option<Role>,
170 pub content: Option<String>,
171}
172
173#[derive(Deserialize, Debug)]
174pub struct LanguageModelUsage {
175 pub prompt_tokens: u32,
176 pub completion_tokens: u32,
177 pub total_tokens: u32,
178}
179
180#[derive(Deserialize, Debug)]
181pub struct LanguageModelChoiceDelta {
182 pub index: u32,
183 pub delta: LanguageModelResponseMessage,
184 pub finish_reason: Option<String>,
185}
186
187#[derive(Clone, Debug, Serialize, Deserialize)]
188struct MessageMetadata {
189 role: Role,
190 status: MessageStatus,
191 // TODO: Delete this
192 #[serde(skip)]
193 ambient_context: AmbientContextSnapshot,
194}
195
196#[derive(Clone, Debug, Serialize, Deserialize)]
197enum MessageStatus {
198 Pending,
199 Done,
200 Error(SharedString),
201}
202
203/// The state pertaining to the Assistant.
204#[derive(Default)]
205struct Assistant {
206 /// Whether the Assistant is enabled.
207 enabled: bool,
208}
209
210impl Global for Assistant {}
211
212impl Assistant {
213 const NAMESPACE: &'static str = "assistant";
214
215 fn set_enabled(&mut self, enabled: bool, cx: &mut AppContext) {
216 if self.enabled == enabled {
217 return;
218 }
219
220 self.enabled = enabled;
221
222 if !enabled {
223 CommandPaletteFilter::update_global(cx, |filter, _cx| {
224 filter.hide_namespace(Self::NAMESPACE);
225 });
226
227 return;
228 }
229
230 CommandPaletteFilter::update_global(cx, |filter, _cx| {
231 filter.show_namespace(Self::NAMESPACE);
232 });
233 }
234}
235
236pub fn init(client: Arc<Client>, cx: &mut AppContext) {
237 cx.set_global(Assistant::default());
238 AssistantSettings::register(cx);
239 completion_provider::init(client, cx);
240 assistant_slash_command::init(cx);
241 assistant_panel::init(cx);
242
243 CommandPaletteFilter::update_global(cx, |filter, _cx| {
244 filter.hide_namespace(Assistant::NAMESPACE);
245 });
246 Assistant::update_global(cx, |assistant, cx| {
247 let settings = AssistantSettings::get_global(cx);
248
249 assistant.set_enabled(settings.enabled, cx);
250 });
251 cx.observe_global::<SettingsStore>(|cx| {
252 Assistant::update_global(cx, |assistant, cx| {
253 let settings = AssistantSettings::get_global(cx);
254
255 assistant.set_enabled(settings.enabled, cx);
256 });
257 })
258 .detach();
259}
260
261#[cfg(test)]
262#[ctor::ctor]
263fn init_logger() {
264 if std::env::var("RUST_LOG").is_ok() {
265 env_logger::init();
266 }
267}