1use anyhow::{Result, anyhow};
2use collections::{BTreeMap, HashMap};
3use deepseek::DEEPSEEK_API_URL;
4
5use futures::Stream;
6use futures::{FutureExt, StreamExt, future, future::BoxFuture, stream::BoxStream};
7use gpui::{AnyView, App, AsyncApp, Context, Entity, SharedString, Task, Window};
8use http_client::HttpClient;
9use language_model::{
10 AuthenticateError, LanguageModel, LanguageModelCompletionError, LanguageModelCompletionEvent,
11 LanguageModelId, LanguageModelName, LanguageModelProvider, LanguageModelProviderId,
12 LanguageModelProviderName, LanguageModelProviderState, LanguageModelRequest,
13 LanguageModelToolChoice, LanguageModelToolResultContent, LanguageModelToolUse, MessageContent,
14 RateLimiter, Role, StopReason, TokenUsage,
15};
16pub use settings::DeepseekAvailableModel as AvailableModel;
17use settings::{Settings, SettingsStore};
18use std::pin::Pin;
19use std::str::FromStr;
20use std::sync::{Arc, LazyLock};
21
22use ui::{Icon, IconName, List, prelude::*};
23use ui_input::SingleLineInput;
24use util::{ResultExt, truncate_and_trailoff};
25use zed_env_vars::{EnvVar, env_var};
26
27use crate::{api_key::ApiKeyState, ui::InstructionListItem};
28
29const PROVIDER_ID: LanguageModelProviderId = LanguageModelProviderId::new("deepseek");
30const PROVIDER_NAME: LanguageModelProviderName = LanguageModelProviderName::new("DeepSeek");
31
32const API_KEY_ENV_VAR_NAME: &str = "DEEPSEEK_API_KEY";
33static API_KEY_ENV_VAR: LazyLock<EnvVar> = env_var!(API_KEY_ENV_VAR_NAME);
34
35#[derive(Default)]
36struct RawToolCall {
37 id: String,
38 name: String,
39 arguments: String,
40}
41
42#[derive(Default, Clone, Debug, PartialEq)]
43pub struct DeepSeekSettings {
44 pub api_url: String,
45 pub available_models: Vec<AvailableModel>,
46}
47pub struct DeepSeekLanguageModelProvider {
48 http_client: Arc<dyn HttpClient>,
49 state: Entity<State>,
50}
51
52pub struct State {
53 api_key_state: ApiKeyState,
54}
55
56impl State {
57 fn is_authenticated(&self) -> bool {
58 self.api_key_state.has_key()
59 }
60
61 fn set_api_key(&mut self, api_key: Option<String>, cx: &mut Context<Self>) -> Task<Result<()>> {
62 let api_url = DeepSeekLanguageModelProvider::api_url(cx);
63 self.api_key_state
64 .store(api_url, api_key, |this| &mut this.api_key_state, cx)
65 }
66
67 fn authenticate(&mut self, cx: &mut Context<Self>) -> Task<Result<(), AuthenticateError>> {
68 let api_url = DeepSeekLanguageModelProvider::api_url(cx);
69 self.api_key_state.load_if_needed(
70 api_url,
71 &API_KEY_ENV_VAR,
72 |this| &mut this.api_key_state,
73 cx,
74 )
75 }
76}
77
78impl DeepSeekLanguageModelProvider {
79 pub fn new(http_client: Arc<dyn HttpClient>, cx: &mut App) -> Self {
80 let state = cx.new(|cx| {
81 cx.observe_global::<SettingsStore>(|this: &mut State, cx| {
82 let api_url = Self::api_url(cx);
83 this.api_key_state.handle_url_change(
84 api_url,
85 &API_KEY_ENV_VAR,
86 |this| &mut this.api_key_state,
87 cx,
88 );
89 cx.notify();
90 })
91 .detach();
92 State {
93 api_key_state: ApiKeyState::new(Self::api_url(cx)),
94 }
95 });
96
97 Self { http_client, state }
98 }
99
100 fn create_language_model(&self, model: deepseek::Model) -> Arc<dyn LanguageModel> {
101 Arc::new(DeepSeekLanguageModel {
102 id: LanguageModelId::from(model.id().to_string()),
103 model,
104 state: self.state.clone(),
105 http_client: self.http_client.clone(),
106 request_limiter: RateLimiter::new(4),
107 })
108 }
109
110 fn settings(cx: &App) -> &DeepSeekSettings {
111 &crate::AllLanguageModelSettings::get_global(cx).deepseek
112 }
113
114 fn api_url(cx: &App) -> SharedString {
115 let api_url = &Self::settings(cx).api_url;
116 if api_url.is_empty() {
117 DEEPSEEK_API_URL.into()
118 } else {
119 SharedString::new(api_url.as_str())
120 }
121 }
122}
123
124impl LanguageModelProviderState for DeepSeekLanguageModelProvider {
125 type ObservableEntity = State;
126
127 fn observable_entity(&self) -> Option<Entity<Self::ObservableEntity>> {
128 Some(self.state.clone())
129 }
130}
131
132impl LanguageModelProvider for DeepSeekLanguageModelProvider {
133 fn id(&self) -> LanguageModelProviderId {
134 PROVIDER_ID
135 }
136
137 fn name(&self) -> LanguageModelProviderName {
138 PROVIDER_NAME
139 }
140
141 fn icon(&self) -> IconName {
142 IconName::AiDeepSeek
143 }
144
145 fn default_model(&self, _cx: &App) -> Option<Arc<dyn LanguageModel>> {
146 Some(self.create_language_model(deepseek::Model::default()))
147 }
148
149 fn default_fast_model(&self, _cx: &App) -> Option<Arc<dyn LanguageModel>> {
150 Some(self.create_language_model(deepseek::Model::default_fast()))
151 }
152
153 fn provided_models(&self, cx: &App) -> Vec<Arc<dyn LanguageModel>> {
154 let mut models = BTreeMap::default();
155
156 models.insert("deepseek-chat", deepseek::Model::Chat);
157 models.insert("deepseek-reasoner", deepseek::Model::Reasoner);
158
159 for available_model in &Self::settings(cx).available_models {
160 models.insert(
161 &available_model.name,
162 deepseek::Model::Custom {
163 name: available_model.name.clone(),
164 display_name: available_model.display_name.clone(),
165 max_tokens: available_model.max_tokens,
166 max_output_tokens: available_model.max_output_tokens,
167 },
168 );
169 }
170
171 models
172 .into_values()
173 .map(|model| self.create_language_model(model))
174 .collect()
175 }
176
177 fn is_authenticated(&self, cx: &App) -> bool {
178 self.state.read(cx).is_authenticated()
179 }
180
181 fn authenticate(&self, cx: &mut App) -> Task<Result<(), AuthenticateError>> {
182 self.state.update(cx, |state, cx| state.authenticate(cx))
183 }
184
185 fn configuration_view(
186 &self,
187 _target_agent: language_model::ConfigurationViewTargetAgent,
188 window: &mut Window,
189 cx: &mut App,
190 ) -> AnyView {
191 cx.new(|cx| ConfigurationView::new(self.state.clone(), window, cx))
192 .into()
193 }
194
195 fn reset_credentials(&self, cx: &mut App) -> Task<Result<()>> {
196 self.state
197 .update(cx, |state, cx| state.set_api_key(None, cx))
198 }
199}
200
201pub struct DeepSeekLanguageModel {
202 id: LanguageModelId,
203 model: deepseek::Model,
204 state: Entity<State>,
205 http_client: Arc<dyn HttpClient>,
206 request_limiter: RateLimiter,
207}
208
209impl DeepSeekLanguageModel {
210 fn stream_completion(
211 &self,
212 request: deepseek::Request,
213 cx: &AsyncApp,
214 ) -> BoxFuture<'static, Result<BoxStream<'static, Result<deepseek::StreamResponse>>>> {
215 let http_client = self.http_client.clone();
216
217 let Ok((api_key, api_url)) = self.state.read_with(cx, |state, cx| {
218 let api_url = DeepSeekLanguageModelProvider::api_url(cx);
219 (state.api_key_state.key(&api_url), api_url)
220 }) else {
221 return future::ready(Err(anyhow!("App state dropped"))).boxed();
222 };
223
224 let future = self.request_limiter.stream(async move {
225 let Some(api_key) = api_key else {
226 return Err(LanguageModelCompletionError::NoApiKey {
227 provider: PROVIDER_NAME,
228 });
229 };
230 let request =
231 deepseek::stream_completion(http_client.as_ref(), &api_url, &api_key, request);
232 let response = request.await?;
233 Ok(response)
234 });
235
236 async move { Ok(future.await?.boxed()) }.boxed()
237 }
238}
239
240impl LanguageModel for DeepSeekLanguageModel {
241 fn id(&self) -> LanguageModelId {
242 self.id.clone()
243 }
244
245 fn name(&self) -> LanguageModelName {
246 LanguageModelName::from(self.model.display_name().to_string())
247 }
248
249 fn provider_id(&self) -> LanguageModelProviderId {
250 PROVIDER_ID
251 }
252
253 fn provider_name(&self) -> LanguageModelProviderName {
254 PROVIDER_NAME
255 }
256
257 fn supports_tools(&self) -> bool {
258 true
259 }
260
261 fn supports_tool_choice(&self, _choice: LanguageModelToolChoice) -> bool {
262 true
263 }
264
265 fn supports_images(&self) -> bool {
266 false
267 }
268
269 fn telemetry_id(&self) -> String {
270 format!("deepseek/{}", self.model.id())
271 }
272
273 fn max_token_count(&self) -> u64 {
274 self.model.max_token_count()
275 }
276
277 fn max_output_tokens(&self) -> Option<u64> {
278 self.model.max_output_tokens()
279 }
280
281 fn count_tokens(
282 &self,
283 request: LanguageModelRequest,
284 cx: &App,
285 ) -> BoxFuture<'static, Result<u64>> {
286 cx.background_spawn(async move {
287 let messages = request
288 .messages
289 .into_iter()
290 .map(|message| tiktoken_rs::ChatCompletionRequestMessage {
291 role: match message.role {
292 Role::User => "user".into(),
293 Role::Assistant => "assistant".into(),
294 Role::System => "system".into(),
295 },
296 content: Some(message.string_contents()),
297 name: None,
298 function_call: None,
299 })
300 .collect::<Vec<_>>();
301
302 tiktoken_rs::num_tokens_from_messages("gpt-4", &messages).map(|tokens| tokens as u64)
303 })
304 .boxed()
305 }
306
307 fn stream_completion(
308 &self,
309 request: LanguageModelRequest,
310 cx: &AsyncApp,
311 ) -> BoxFuture<
312 'static,
313 Result<
314 BoxStream<'static, Result<LanguageModelCompletionEvent, LanguageModelCompletionError>>,
315 LanguageModelCompletionError,
316 >,
317 > {
318 let request = into_deepseek(request, &self.model, self.max_output_tokens());
319 let stream = self.stream_completion(request, cx);
320
321 async move {
322 let mapper = DeepSeekEventMapper::new();
323 Ok(mapper.map_stream(stream.await?).boxed())
324 }
325 .boxed()
326 }
327}
328
329pub fn into_deepseek(
330 request: LanguageModelRequest,
331 model: &deepseek::Model,
332 max_output_tokens: Option<u64>,
333) -> deepseek::Request {
334 let is_reasoner = *model == deepseek::Model::Reasoner;
335
336 let mut messages = Vec::new();
337 for message in request.messages {
338 for content in message.content {
339 match content {
340 MessageContent::Text(text) => messages.push(match message.role {
341 Role::User => deepseek::RequestMessage::User { content: text },
342 Role::Assistant => deepseek::RequestMessage::Assistant {
343 content: Some(text),
344 tool_calls: Vec::new(),
345 },
346 Role::System => deepseek::RequestMessage::System { content: text },
347 }),
348 MessageContent::Thinking { .. } => {}
349 MessageContent::RedactedThinking(_) => {}
350 MessageContent::Image(_) => {}
351 MessageContent::ToolUse(tool_use) => {
352 let tool_call = deepseek::ToolCall {
353 id: tool_use.id.to_string(),
354 content: deepseek::ToolCallContent::Function {
355 function: deepseek::FunctionContent {
356 name: tool_use.name.to_string(),
357 arguments: serde_json::to_string(&tool_use.input)
358 .unwrap_or_default(),
359 },
360 },
361 };
362
363 if let Some(deepseek::RequestMessage::Assistant { tool_calls, .. }) =
364 messages.last_mut()
365 {
366 tool_calls.push(tool_call);
367 } else {
368 messages.push(deepseek::RequestMessage::Assistant {
369 content: None,
370 tool_calls: vec![tool_call],
371 });
372 }
373 }
374 MessageContent::ToolResult(tool_result) => {
375 match &tool_result.content {
376 LanguageModelToolResultContent::Text(text) => {
377 messages.push(deepseek::RequestMessage::Tool {
378 content: text.to_string(),
379 tool_call_id: tool_result.tool_use_id.to_string(),
380 });
381 }
382 LanguageModelToolResultContent::Image(_) => {}
383 };
384 }
385 }
386 }
387 }
388
389 deepseek::Request {
390 model: model.id().to_string(),
391 messages,
392 stream: true,
393 max_tokens: max_output_tokens,
394 temperature: if is_reasoner {
395 None
396 } else {
397 request.temperature
398 },
399 response_format: None,
400 tools: request
401 .tools
402 .into_iter()
403 .map(|tool| deepseek::ToolDefinition::Function {
404 function: deepseek::FunctionDefinition {
405 name: tool.name,
406 description: Some(tool.description),
407 parameters: Some(tool.input_schema),
408 },
409 })
410 .collect(),
411 }
412}
413
414pub struct DeepSeekEventMapper {
415 tool_calls_by_index: HashMap<usize, RawToolCall>,
416}
417
418impl DeepSeekEventMapper {
419 pub fn new() -> Self {
420 Self {
421 tool_calls_by_index: HashMap::default(),
422 }
423 }
424
425 pub fn map_stream(
426 mut self,
427 events: Pin<Box<dyn Send + Stream<Item = Result<deepseek::StreamResponse>>>>,
428 ) -> impl Stream<Item = Result<LanguageModelCompletionEvent, LanguageModelCompletionError>>
429 {
430 events.flat_map(move |event| {
431 futures::stream::iter(match event {
432 Ok(event) => self.map_event(event),
433 Err(error) => vec![Err(LanguageModelCompletionError::from(error))],
434 })
435 })
436 }
437
438 pub fn map_event(
439 &mut self,
440 event: deepseek::StreamResponse,
441 ) -> Vec<Result<LanguageModelCompletionEvent, LanguageModelCompletionError>> {
442 let Some(choice) = event.choices.first() else {
443 return vec![Err(LanguageModelCompletionError::from(anyhow!(
444 "Response contained no choices"
445 )))];
446 };
447
448 let mut events = Vec::new();
449 if let Some(content) = choice.delta.content.clone() {
450 events.push(Ok(LanguageModelCompletionEvent::Text(content)));
451 }
452
453 if let Some(reasoning_content) = choice.delta.reasoning_content.clone() {
454 events.push(Ok(LanguageModelCompletionEvent::Thinking {
455 text: reasoning_content,
456 signature: None,
457 }));
458 }
459
460 if let Some(tool_calls) = choice.delta.tool_calls.as_ref() {
461 for tool_call in tool_calls {
462 let entry = self.tool_calls_by_index.entry(tool_call.index).or_default();
463
464 if let Some(tool_id) = tool_call.id.clone() {
465 entry.id = tool_id;
466 }
467
468 if let Some(function) = tool_call.function.as_ref() {
469 if let Some(name) = function.name.clone() {
470 entry.name = name;
471 }
472
473 if let Some(arguments) = function.arguments.clone() {
474 entry.arguments.push_str(&arguments);
475 }
476 }
477 }
478 }
479
480 if let Some(usage) = event.usage {
481 events.push(Ok(LanguageModelCompletionEvent::UsageUpdate(TokenUsage {
482 input_tokens: usage.prompt_tokens,
483 output_tokens: usage.completion_tokens,
484 cache_creation_input_tokens: 0,
485 cache_read_input_tokens: 0,
486 })));
487 }
488
489 match choice.finish_reason.as_deref() {
490 Some("stop") => {
491 events.push(Ok(LanguageModelCompletionEvent::Stop(StopReason::EndTurn)));
492 }
493 Some("tool_calls") => {
494 events.extend(self.tool_calls_by_index.drain().map(|(_, tool_call)| {
495 match serde_json::Value::from_str(&tool_call.arguments) {
496 Ok(input) => Ok(LanguageModelCompletionEvent::ToolUse(
497 LanguageModelToolUse {
498 id: tool_call.id.clone().into(),
499 name: tool_call.name.as_str().into(),
500 is_input_complete: true,
501 input,
502 raw_input: tool_call.arguments.clone(),
503 },
504 )),
505 Err(error) => Ok(LanguageModelCompletionEvent::ToolUseJsonParseError {
506 id: tool_call.id.clone().into(),
507 tool_name: tool_call.name.as_str().into(),
508 raw_input: tool_call.arguments.into(),
509 json_parse_error: error.to_string(),
510 }),
511 }
512 }));
513
514 events.push(Ok(LanguageModelCompletionEvent::Stop(StopReason::ToolUse)));
515 }
516 Some(stop_reason) => {
517 log::error!("Unexpected DeepSeek stop_reason: {stop_reason:?}",);
518 events.push(Ok(LanguageModelCompletionEvent::Stop(StopReason::EndTurn)));
519 }
520 None => {}
521 }
522
523 events
524 }
525}
526
527struct ConfigurationView {
528 api_key_editor: Entity<SingleLineInput>,
529 state: Entity<State>,
530 load_credentials_task: Option<Task<()>>,
531}
532
533impl ConfigurationView {
534 fn new(state: Entity<State>, window: &mut Window, cx: &mut Context<Self>) -> Self {
535 let api_key_editor =
536 cx.new(|cx| SingleLineInput::new(window, cx, "sk-00000000000000000000000000000000"));
537
538 cx.observe(&state, |_, _, cx| {
539 cx.notify();
540 })
541 .detach();
542
543 let load_credentials_task = Some(cx.spawn({
544 let state = state.clone();
545 async move |this, cx| {
546 if let Some(task) = state
547 .update(cx, |state, cx| state.authenticate(cx))
548 .log_err()
549 {
550 let _ = task.await;
551 }
552
553 this.update(cx, |this, cx| {
554 this.load_credentials_task = None;
555 cx.notify();
556 })
557 .log_err();
558 }
559 }));
560
561 Self {
562 api_key_editor,
563 state,
564 load_credentials_task,
565 }
566 }
567
568 fn save_api_key(&mut self, _: &menu::Confirm, _window: &mut Window, cx: &mut Context<Self>) {
569 let api_key = self.api_key_editor.read(cx).text(cx).trim().to_string();
570 if api_key.is_empty() {
571 return;
572 }
573
574 let state = self.state.clone();
575 cx.spawn(async move |_, cx| {
576 state
577 .update(cx, |state, cx| state.set_api_key(Some(api_key), cx))?
578 .await
579 })
580 .detach_and_log_err(cx);
581 }
582
583 fn reset_api_key(&mut self, window: &mut Window, cx: &mut Context<Self>) {
584 self.api_key_editor
585 .update(cx, |editor, cx| editor.set_text("", window, cx));
586
587 let state = self.state.clone();
588 cx.spawn(async move |_, cx| {
589 state
590 .update(cx, |state, cx| state.set_api_key(None, cx))?
591 .await
592 })
593 .detach_and_log_err(cx);
594 }
595
596 fn should_render_editor(&self, cx: &mut Context<Self>) -> bool {
597 !self.state.read(cx).is_authenticated()
598 }
599}
600
601impl Render for ConfigurationView {
602 fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
603 let env_var_set = self.state.read(cx).api_key_state.is_from_env_var();
604
605 if self.load_credentials_task.is_some() {
606 div().child(Label::new("Loading credentials...")).into_any()
607 } else if self.should_render_editor(cx) {
608 v_flex()
609 .size_full()
610 .on_action(cx.listener(Self::save_api_key))
611 .child(Label::new("To use DeepSeek in Zed, you need an API key:"))
612 .child(
613 List::new()
614 .child(InstructionListItem::new(
615 "Get your API key from the",
616 Some("DeepSeek console"),
617 Some("https://platform.deepseek.com/api_keys"),
618 ))
619 .child(InstructionListItem::text_only(
620 "Paste your API key below and hit enter to start using the assistant",
621 )),
622 )
623 .child(self.api_key_editor.clone())
624 .child(
625 Label::new(format!(
626 "Or set the {API_KEY_ENV_VAR_NAME} environment variable."
627 ))
628 .size(LabelSize::Small)
629 .color(Color::Muted),
630 )
631 .into_any()
632 } else {
633 h_flex()
634 .mt_1()
635 .p_1()
636 .justify_between()
637 .rounded_md()
638 .border_1()
639 .border_color(cx.theme().colors().border)
640 .bg(cx.theme().colors().background)
641 .child(
642 h_flex()
643 .gap_1()
644 .child(Icon::new(IconName::Check).color(Color::Success))
645 .child(Label::new(if env_var_set {
646 format!("API key set in {API_KEY_ENV_VAR_NAME} environment variable")
647 } else {
648 let api_url = DeepSeekLanguageModelProvider::api_url(cx);
649 if api_url == DEEPSEEK_API_URL {
650 "API key configured".to_string()
651 } else {
652 format!(
653 "API key configured for {}",
654 truncate_and_trailoff(&api_url, 32)
655 )
656 }
657 })),
658 )
659 .child(
660 Button::new("reset-key", "Reset Key")
661 .label_size(LabelSize::Small)
662 .icon(Some(IconName::Trash))
663 .icon_size(IconSize::Small)
664 .icon_position(IconPosition::Start)
665 .disabled(env_var_set)
666 .on_click(
667 cx.listener(|this, _, window, cx| this.reset_api_key(window, cx)),
668 ),
669 )
670 .into_any()
671 }
672 }
673}