use anyhow::{Context as _, Result, anyhow};use collections::{BTreeMap, HashMap};use credentials_provider::CredentialsProvider;use editor::{Editor, EditorElement, EditorStyle};use futures::Stream;use futures::{FutureExt, StreamExt, future::BoxFuture, stream::BoxStream};use gpui::{ AnyView, AppContext as _, AsyncApp, Entity, FontStyle, Subscription, Task, TextStyle, WhiteSpace,};use http_client::HttpClient;use language_model::{ AuthenticateError, LanguageModel, LanguageModelCompletionError, LanguageModelCompletionEvent, LanguageModelId, LanguageModelName, LanguageModelProvider, LanguageModelProviderId, LanguageModelProviderName, LanguageModelProviderState, LanguageModelRequest, LanguageModelToolChoice, LanguageModelToolResultContent, LanguageModelToolUse, MessageContent, RateLimiter, Role, StopReason,};use schemars::JsonSchema;use serde::{Deserialize, Serialize};use settings::{Settings, SettingsStore};use std::pin::Pin;use std::str::FromStr;use std::sync::Arc;use theme::ThemeSettings;use ui::{Icon, IconName, List, prelude::*};use util::ResultExt; use crate::{AllLanguageModelSettings, ui::InstructionListItem}; const PROVIDER_ID: &str = "deepseek";const PROVIDER_NAME: &str = "DeepSeek";const DEEPSEEK_API_KEY_VAR: &str = "DEEPSEEK_API_KEY"; #[derive(Default)]struct RawToolCall { id: String, name: String, arguments: String,} #[derive(Default, Clone, Debug, PartialEq)]pub struct DeepSeekSettings { pub api_url: String, pub available_models: Vec<AvailableModel>,} #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, JsonSchema)]pub struct AvailableModel { pub name: String, pub display_name: Option<String>, pub max_tokens: usize, pub max_output_tokens: Option<u32>,} pub struct DeepSeekLanguageModelProvider { http_client: Arc<dyn HttpClient>, state: Entity<State>,} pub struct State { api_key: Option<String>, api_key_from_env: bool, _subscription: Subscription,} impl State { fn is_authenticated(&self) -> bool { self.api_key.is_some() } fn reset_api_key(&self, cx: &mut Context<Self>) -> Task<Result<()>> { let credentials_provider = <dyn CredentialsProvider>::global(cx); let api_url = AllLanguageModelSettings::get_global(cx) .deepseek .api_url .clone(); cx.spawn(async move |this, cx| { credentials_provider .delete_credentials(&api_url, &cx) .await .log_err(); this.update(cx, |this, cx| { this.api_key = None; this.api_key_from_env = false; cx.notify(); }) }) } fn set_api_key(&mut self, api_key: String, cx: &mut Context<Self>) -> Task<Result<()>> { let credentials_provider = <dyn CredentialsProvider>::global(cx); let api_url = AllLanguageModelSettings::get_global(cx) .deepseek .api_url .clone(); cx.spawn(async move |this, cx| { credentials_provider .write_credentials(&api_url, "Bearer", api_key.as_bytes(), &cx) .await?; this.update(cx, |this, cx| { this.api_key = Some(api_key); cx.notify(); }) }) } fn authenticate(&self, cx: &mut Context<Self>) -> Task<Result<(), AuthenticateError>> { if self.is_authenticated() { return Task::ready(Ok(())); } let credentials_provider = <dyn CredentialsProvider>::global(cx); let api_url = AllLanguageModelSettings::get_global(cx) .deepseek .api_url .clone(); cx.spawn(async move |this, cx| { let (api_key, from_env) = if let Ok(api_key) = std::env::var(DEEPSEEK_API_KEY_VAR) { (api_key, true) } else { let (_, api_key) = credentials_provider .read_credentials(&api_url, &cx) .await? .ok_or(AuthenticateError::CredentialsNotFound)?; ( String::from_utf8(api_key).context("invalid {PROVIDER_NAME} API key")?, false, ) }; this.update(cx, |this, cx| { this.api_key = Some(api_key); this.api_key_from_env = from_env; cx.notify(); })?; Ok(()) }) }} impl DeepSeekLanguageModelProvider { pub fn new(http_client: Arc<dyn HttpClient>, cx: &mut App) -> Self { let state = cx.new(|cx| State { api_key: None, api_key_from_env: false, _subscription: cx.observe_global::<SettingsStore>(|_this: &mut State, cx| { cx.notify(); }), }); Self { http_client, state } } fn create_language_model(&self, model: deepseek::Model) -> Arc<dyn LanguageModel> { Arc::new(DeepSeekLanguageModel { id: LanguageModelId::from(model.id().to_string()), model, state: self.state.clone(), http_client: self.http_client.clone(), request_limiter: RateLimiter::new(4), }) as Arc<dyn LanguageModel> }} impl LanguageModelProviderState for DeepSeekLanguageModelProvider { type ObservableEntity = State; fn observable_entity(&self) -> Option<Entity<Self::ObservableEntity>> { Some(self.state.clone()) }} impl LanguageModelProvider for DeepSeekLanguageModelProvider { fn id(&self) -> LanguageModelProviderId { LanguageModelProviderId(PROVIDER_ID.into()) } fn name(&self) -> LanguageModelProviderName { LanguageModelProviderName(PROVIDER_NAME.into()) } fn icon(&self) -> IconName { IconName::AiDeepSeek } fn default_model(&self, _cx: &App) -> Option<Arc<dyn LanguageModel>> { Some(self.create_language_model(deepseek::Model::default())) } fn default_fast_model(&self, _cx: &App) -> Option<Arc<dyn LanguageModel>> { Some(self.create_language_model(deepseek::Model::default_fast())) } fn provided_models(&self, cx: &App) -> Vec<Arc<dyn LanguageModel>> { let mut models = BTreeMap::default(); models.insert("deepseek-chat", deepseek::Model::Chat); models.insert("deepseek-reasoner", deepseek::Model::Reasoner); for available_model in AllLanguageModelSettings::get_global(cx) .deepseek .available_models .iter() { models.insert( &available_model.name, deepseek::Model::Custom { name: available_model.name.clone(), display_name: available_model.display_name.clone(), max_tokens: available_model.max_tokens, max_output_tokens: available_model.max_output_tokens, }, ); } models .into_values() .map(|model| self.create_language_model(model)) .collect() } fn is_authenticated(&self, cx: &App) -> bool { self.state.read(cx).is_authenticated() } fn authenticate(&self, cx: &mut App) -> Task<Result<(), AuthenticateError>> { self.state.update(cx, |state, cx| state.authenticate(cx)) } fn configuration_view(&self, window: &mut Window, cx: &mut App) -> AnyView { cx.new(|cx| ConfigurationView::new(self.state.clone(), window, cx)) .into() } fn reset_credentials(&self, cx: &mut App) -> Task<Result<()>> { self.state.update(cx, |state, cx| state.reset_api_key(cx)) }} pub struct DeepSeekLanguageModel { id: LanguageModelId, model: deepseek::Model, state: Entity<State>, http_client: Arc<dyn HttpClient>, request_limiter: RateLimiter,} impl DeepSeekLanguageModel { fn stream_completion( &self, request: deepseek::Request, cx: &AsyncApp, ) -> BoxFuture<'static, Result<BoxStream<'static, Result<deepseek::StreamResponse>>>> { let http_client = self.http_client.clone(); let Ok((api_key, api_url)) = cx.read_entity(&self.state, |state, cx| { let settings = &AllLanguageModelSettings::get_global(cx).deepseek; (state.api_key.clone(), settings.api_url.clone()) }) else { return futures::future::ready(Err(anyhow!("App state dropped"))).boxed(); }; let future = self.request_limiter.stream(async move { let api_key = api_key.context("Missing DeepSeek API Key")?; let request = deepseek::stream_completion(http_client.as_ref(), &api_url, &api_key, request); let response = request.await?; Ok(response) }); async move { Ok(future.await?.boxed()) }.boxed() }} impl LanguageModel for DeepSeekLanguageModel { fn id(&self) -> LanguageModelId { self.id.clone() } fn name(&self) -> LanguageModelName { LanguageModelName::from(self.model.display_name().to_string()) } fn provider_id(&self) -> LanguageModelProviderId { LanguageModelProviderId(PROVIDER_ID.into()) } fn provider_name(&self) -> LanguageModelProviderName { LanguageModelProviderName(PROVIDER_NAME.into()) } fn supports_tools(&self) -> bool { true } fn supports_tool_choice(&self, _choice: LanguageModelToolChoice) -> bool { true } fn supports_images(&self) -> bool { false } fn telemetry_id(&self) -> String { format!("deepseek/{}", self.model.id()) } fn max_token_count(&self) -> usize { self.model.max_token_count() } fn max_output_tokens(&self) -> Option<u32> { self.model.max_output_tokens() } fn count_tokens( &self, request: LanguageModelRequest, cx: &App, ) -> BoxFuture<'static, Result<usize>> { cx.background_spawn(async move { let messages = request .messages .into_iter() .map(|message| tiktoken_rs::ChatCompletionRequestMessage { role: match message.role { Role::User => "user".into(), Role::Assistant => "assistant".into(), Role::System => "system".into(), }, content: Some(message.string_contents()), name: None, function_call: None, }) .collect::<Vec<_>>(); tiktoken_rs::num_tokens_from_messages("gpt-4", &messages) }) .boxed() } fn stream_completion( &self, request: LanguageModelRequest, cx: &AsyncApp, ) -> BoxFuture< 'static, Result< BoxStream<'static, Result<LanguageModelCompletionEvent, LanguageModelCompletionError>>, >, > { let request = into_deepseek(request, &self.model, self.max_output_tokens()); let stream = self.stream_completion(request, cx); async move { let mapper = DeepSeekEventMapper::new(); Ok(mapper.map_stream(stream.await?).boxed()) } .boxed() }} pub fn into_deepseek( request: LanguageModelRequest, model: &deepseek::Model, max_output_tokens: Option<u32>,) -> deepseek::Request { let is_reasoner = *model == deepseek::Model::Reasoner; let mut messages = Vec::new(); for message in request.messages { for content in message.content { match content { MessageContent::Text(text) | MessageContent::Thinking { text, .. } => messages .push(match message.role { Role::User => deepseek::RequestMessage::User { content: text }, Role::Assistant => deepseek::RequestMessage::Assistant { content: Some(text), tool_calls: Vec::new(), }, Role::System => deepseek::RequestMessage::System { content: text }, }), MessageContent::RedactedThinking(_) => {} MessageContent::Image(_) => {} MessageContent::ToolUse(tool_use) => { let tool_call = deepseek::ToolCall { id: tool_use.id.to_string(), content: deepseek::ToolCallContent::Function { function: deepseek::FunctionContent { name: tool_use.name.to_string(), arguments: serde_json::to_string(&tool_use.input) .unwrap_or_default(), }, }, }; if let Some(deepseek::RequestMessage::Assistant { tool_calls, .. }) = messages.last_mut() { tool_calls.push(tool_call); } else { messages.push(deepseek::RequestMessage::Assistant { content: None, tool_calls: vec![tool_call], }); } } MessageContent::ToolResult(tool_result) => { match &tool_result.content { LanguageModelToolResultContent::Text(text) => { messages.push(deepseek::RequestMessage::Tool { content: text.to_string(), tool_call_id: tool_result.tool_use_id.to_string(), }); } LanguageModelToolResultContent::Image(_) => {} }; } } } } deepseek::Request { model: model.id().to_string(), messages, stream: true, max_tokens: max_output_tokens, temperature: if is_reasoner { None } else { request.temperature }, response_format: None, tools: request .tools .into_iter() .map(|tool| deepseek::ToolDefinition::Function { function: deepseek::FunctionDefinition { name: tool.name, description: Some(tool.description), parameters: Some(tool.input_schema), }, }) .collect(), }} pub struct DeepSeekEventMapper { tool_calls_by_index: HashMap<usize, RawToolCall>,} impl DeepSeekEventMapper { pub fn new() -> Self { Self { tool_calls_by_index: HashMap::default(), } } pub fn map_stream( mut self, events: Pin<Box<dyn Send + Stream<Item = Result<deepseek::StreamResponse>>>>, ) -> impl Stream<Item = Result<LanguageModelCompletionEvent, LanguageModelCompletionError>> { events.flat_map(move |event| { futures::stream::iter(match event { Ok(event) => self.map_event(event), Err(error) => vec![Err(LanguageModelCompletionError::Other(anyhow!(error)))], }) }) } pub fn map_event( &mut self, event: deepseek::StreamResponse, ) -> Vec<Result<LanguageModelCompletionEvent, LanguageModelCompletionError>> { let Some(choice) = event.choices.first() else { return vec![Err(LanguageModelCompletionError::Other(anyhow!( "Response contained no choices" )))]; }; let mut events = Vec::new(); if let Some(content) = choice.delta.content.clone() { events.push(Ok(LanguageModelCompletionEvent::Text(content))); } if let Some(tool_calls) = choice.delta.tool_calls.as_ref() { for tool_call in tool_calls { let entry = self.tool_calls_by_index.entry(tool_call.index).or_default(); if let Some(tool_id) = tool_call.id.clone() { entry.id = tool_id; } if let Some(function) = tool_call.function.as_ref() { if let Some(name) = function.name.clone() { entry.name = name; } Lines 1–500 of 727. Load more
use anyhow::{Context as _, Result, anyhow}; use collections::{BTreeMap, HashMap}; use credentials_provider::CredentialsProvider; use editor::{Editor, EditorElement, EditorStyle}; use futures::Stream; use futures::{FutureExt, StreamExt, future::BoxFuture, stream::BoxStream}; use gpui::{ AnyView, AppContext as _, AsyncApp, Entity, FontStyle, Subscription, Task, TextStyle, WhiteSpace, }; use http_client::HttpClient; use language_model::{ AuthenticateError, LanguageModel, LanguageModelCompletionError, LanguageModelCompletionEvent, LanguageModelId, LanguageModelName, LanguageModelProvider, LanguageModelProviderId, LanguageModelProviderName, LanguageModelProviderState, LanguageModelRequest, LanguageModelToolChoice, LanguageModelToolResultContent, LanguageModelToolUse, MessageContent, RateLimiter, Role, StopReason, }; use schemars::JsonSchema; use serde::{Deserialize, Serialize}; use settings::{Settings, SettingsStore}; use std::pin::Pin; use std::str::FromStr; use std::sync::Arc; use theme::ThemeSettings; use ui::{Icon, IconName, List, prelude::*}; use util::ResultExt; use crate::{AllLanguageModelSettings, ui::InstructionListItem}; const PROVIDER_ID: &str = "deepseek"; const PROVIDER_NAME: &str = "DeepSeek"; const DEEPSEEK_API_KEY_VAR: &str = "DEEPSEEK_API_KEY"; #[derive(Default)] struct RawToolCall { id: String, name: String, arguments: String, } #[derive(Default, Clone, Debug, PartialEq)] pub struct DeepSeekSettings { pub api_url: String, pub available_models: Vec<AvailableModel>, } #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, JsonSchema)] pub struct AvailableModel { pub name: String, pub display_name: Option<String>, pub max_tokens: usize, pub max_output_tokens: Option<u32>, } pub struct DeepSeekLanguageModelProvider { http_client: Arc<dyn HttpClient>, state: Entity<State>, } pub struct State { api_key: Option<String>, api_key_from_env: bool, _subscription: Subscription, } impl State { fn is_authenticated(&self) -> bool { self.api_key.is_some() } fn reset_api_key(&self, cx: &mut Context<Self>) -> Task<Result<()>> { let credentials_provider = <dyn CredentialsProvider>::global(cx); let api_url = AllLanguageModelSettings::get_global(cx) .deepseek .api_url .clone(); cx.spawn(async move |this, cx| { credentials_provider .delete_credentials(&api_url, &cx) .await .log_err(); this.update(cx, |this, cx| { this.api_key = None; this.api_key_from_env = false; cx.notify(); }) }) } fn set_api_key(&mut self, api_key: String, cx: &mut Context<Self>) -> Task<Result<()>> { let credentials_provider = <dyn CredentialsProvider>::global(cx); let api_url = AllLanguageModelSettings::get_global(cx) .deepseek .api_url .clone(); cx.spawn(async move |this, cx| { credentials_provider .write_credentials(&api_url, "Bearer", api_key.as_bytes(), &cx) .await?; this.update(cx, |this, cx| { this.api_key = Some(api_key); cx.notify(); }) }) } fn authenticate(&self, cx: &mut Context<Self>) -> Task<Result<(), AuthenticateError>> { if self.is_authenticated() { return Task::ready(Ok(())); } let credentials_provider = <dyn CredentialsProvider>::global(cx); let api_url = AllLanguageModelSettings::get_global(cx) .deepseek .api_url .clone(); cx.spawn(async move |this, cx| { let (api_key, from_env) = if let Ok(api_key) = std::env::var(DEEPSEEK_API_KEY_VAR) { (api_key, true) } else { let (_, api_key) = credentials_provider .read_credentials(&api_url, &cx) .await? .ok_or(AuthenticateError::CredentialsNotFound)?; ( String::from_utf8(api_key).context("invalid {PROVIDER_NAME} API key")?, false, ) }; this.update(cx, |this, cx| { this.api_key = Some(api_key); this.api_key_from_env = from_env; cx.notify(); })?; Ok(()) }) } } impl DeepSeekLanguageModelProvider { pub fn new(http_client: Arc<dyn HttpClient>, cx: &mut App) -> Self { let state = cx.new(|cx| State { api_key: None, api_key_from_env: false, _subscription: cx.observe_global::<SettingsStore>(|_this: &mut State, cx| { cx.notify(); }), }); Self { http_client, state } } fn create_language_model(&self, model: deepseek::Model) -> Arc<dyn LanguageModel> { Arc::new(DeepSeekLanguageModel { id: LanguageModelId::from(model.id().to_string()), model, state: self.state.clone(), http_client: self.http_client.clone(), request_limiter: RateLimiter::new(4), }) as Arc<dyn LanguageModel> } } impl LanguageModelProviderState for DeepSeekLanguageModelProvider { type ObservableEntity = State; fn observable_entity(&self) -> Option<Entity<Self::ObservableEntity>> { Some(self.state.clone()) } } impl LanguageModelProvider for DeepSeekLanguageModelProvider { fn id(&self) -> LanguageModelProviderId { LanguageModelProviderId(PROVIDER_ID.into()) } fn name(&self) -> LanguageModelProviderName { LanguageModelProviderName(PROVIDER_NAME.into()) } fn icon(&self) -> IconName { IconName::AiDeepSeek } fn default_model(&self, _cx: &App) -> Option<Arc<dyn LanguageModel>> { Some(self.create_language_model(deepseek::Model::default())) } fn default_fast_model(&self, _cx: &App) -> Option<Arc<dyn LanguageModel>> { Some(self.create_language_model(deepseek::Model::default_fast())) } fn provided_models(&self, cx: &App) -> Vec<Arc<dyn LanguageModel>> { let mut models = BTreeMap::default(); models.insert("deepseek-chat", deepseek::Model::Chat); models.insert("deepseek-reasoner", deepseek::Model::Reasoner); for available_model in AllLanguageModelSettings::get_global(cx) .deepseek .available_models .iter() { models.insert( &available_model.name, deepseek::Model::Custom { name: available_model.name.clone(), display_name: available_model.display_name.clone(), max_tokens: available_model.max_tokens, max_output_tokens: available_model.max_output_tokens, }, ); } models .into_values() .map(|model| self.create_language_model(model)) .collect() } fn is_authenticated(&self, cx: &App) -> bool { self.state.read(cx).is_authenticated() } fn authenticate(&self, cx: &mut App) -> Task<Result<(), AuthenticateError>> { self.state.update(cx, |state, cx| state.authenticate(cx)) } fn configuration_view(&self, window: &mut Window, cx: &mut App) -> AnyView { cx.new(|cx| ConfigurationView::new(self.state.clone(), window, cx)) .into() } fn reset_credentials(&self, cx: &mut App) -> Task<Result<()>> { self.state.update(cx, |state, cx| state.reset_api_key(cx)) } } pub struct DeepSeekLanguageModel { id: LanguageModelId, model: deepseek::Model, state: Entity<State>, http_client: Arc<dyn HttpClient>, request_limiter: RateLimiter, } impl DeepSeekLanguageModel { fn stream_completion( &self, request: deepseek::Request, cx: &AsyncApp, ) -> BoxFuture<'static, Result<BoxStream<'static, Result<deepseek::StreamResponse>>>> { let http_client = self.http_client.clone(); let Ok((api_key, api_url)) = cx.read_entity(&self.state, |state, cx| { let settings = &AllLanguageModelSettings::get_global(cx).deepseek; (state.api_key.clone(), settings.api_url.clone()) }) else { return futures::future::ready(Err(anyhow!("App state dropped"))).boxed(); }; let future = self.request_limiter.stream(async move { let api_key = api_key.context("Missing DeepSeek API Key")?; let request = deepseek::stream_completion(http_client.as_ref(), &api_url, &api_key, request); let response = request.await?; Ok(response) }); async move { Ok(future.await?.boxed()) }.boxed() } } impl LanguageModel for DeepSeekLanguageModel { fn id(&self) -> LanguageModelId { self.id.clone() } fn name(&self) -> LanguageModelName { LanguageModelName::from(self.model.display_name().to_string()) } fn provider_id(&self) -> LanguageModelProviderId { LanguageModelProviderId(PROVIDER_ID.into()) } fn provider_name(&self) -> LanguageModelProviderName { LanguageModelProviderName(PROVIDER_NAME.into()) } fn supports_tools(&self) -> bool { true } fn supports_tool_choice(&self, _choice: LanguageModelToolChoice) -> bool { true } fn supports_images(&self) -> bool { false } fn telemetry_id(&self) -> String { format!("deepseek/{}", self.model.id()) } fn max_token_count(&self) -> usize { self.model.max_token_count() } fn max_output_tokens(&self) -> Option<u32> { self.model.max_output_tokens() } fn count_tokens( &self, request: LanguageModelRequest, cx: &App, ) -> BoxFuture<'static, Result<usize>> { cx.background_spawn(async move { let messages = request .messages .into_iter() .map(|message| tiktoken_rs::ChatCompletionRequestMessage { role: match message.role { Role::User => "user".into(), Role::Assistant => "assistant".into(), Role::System => "system".into(), }, content: Some(message.string_contents()), name: None, function_call: None, }) .collect::<Vec<_>>(); tiktoken_rs::num_tokens_from_messages("gpt-4", &messages) }) .boxed() } fn stream_completion( &self, request: LanguageModelRequest, cx: &AsyncApp, ) -> BoxFuture< 'static, Result< BoxStream<'static, Result<LanguageModelCompletionEvent, LanguageModelCompletionError>>, >, > { let request = into_deepseek(request, &self.model, self.max_output_tokens()); let stream = self.stream_completion(request, cx); async move { let mapper = DeepSeekEventMapper::new(); Ok(mapper.map_stream(stream.await?).boxed()) } .boxed() } } pub fn into_deepseek( request: LanguageModelRequest, model: &deepseek::Model, max_output_tokens: Option<u32>, ) -> deepseek::Request { let is_reasoner = *model == deepseek::Model::Reasoner; let mut messages = Vec::new(); for message in request.messages { for content in message.content { match content { MessageContent::Text(text) | MessageContent::Thinking { text, .. } => messages .push(match message.role { Role::User => deepseek::RequestMessage::User { content: text }, Role::Assistant => deepseek::RequestMessage::Assistant { content: Some(text), tool_calls: Vec::new(), }, Role::System => deepseek::RequestMessage::System { content: text }, }), MessageContent::RedactedThinking(_) => {} MessageContent::Image(_) => {} MessageContent::ToolUse(tool_use) => { let tool_call = deepseek::ToolCall { id: tool_use.id.to_string(), content: deepseek::ToolCallContent::Function { function: deepseek::FunctionContent { name: tool_use.name.to_string(), arguments: serde_json::to_string(&tool_use.input) .unwrap_or_default(), }, }, }; if let Some(deepseek::RequestMessage::Assistant { tool_calls, .. }) = messages.last_mut() { tool_calls.push(tool_call); } else { messages.push(deepseek::RequestMessage::Assistant { content: None, tool_calls: vec![tool_call], }); } } MessageContent::ToolResult(tool_result) => { match &tool_result.content { LanguageModelToolResultContent::Text(text) => { messages.push(deepseek::RequestMessage::Tool { content: text.to_string(), tool_call_id: tool_result.tool_use_id.to_string(), }); } LanguageModelToolResultContent::Image(_) => {} }; } } } } deepseek::Request { model: model.id().to_string(), messages, stream: true, max_tokens: max_output_tokens, temperature: if is_reasoner { None } else { request.temperature }, response_format: None, tools: request .tools .into_iter() .map(|tool| deepseek::ToolDefinition::Function { function: deepseek::FunctionDefinition { name: tool.name, description: Some(tool.description), parameters: Some(tool.input_schema), }, }) .collect(), } } pub struct DeepSeekEventMapper { tool_calls_by_index: HashMap<usize, RawToolCall>, } impl DeepSeekEventMapper { pub fn new() -> Self { Self { tool_calls_by_index: HashMap::default(), } } pub fn map_stream( mut self, events: Pin<Box<dyn Send + Stream<Item = Result<deepseek::StreamResponse>>>>, ) -> impl Stream<Item = Result<LanguageModelCompletionEvent, LanguageModelCompletionError>> { events.flat_map(move |event| { futures::stream::iter(match event { Ok(event) => self.map_event(event), Err(error) => vec![Err(LanguageModelCompletionError::Other(anyhow!(error)))], }) }) } pub fn map_event( &mut self, event: deepseek::StreamResponse, ) -> Vec<Result<LanguageModelCompletionEvent, LanguageModelCompletionError>> { let Some(choice) = event.choices.first() else { return vec![Err(LanguageModelCompletionError::Other(anyhow!( "Response contained no choices" )))]; }; let mut events = Vec::new(); if let Some(content) = choice.delta.content.clone() { events.push(Ok(LanguageModelCompletionEvent::Text(content))); } if let Some(tool_calls) = choice.delta.tool_calls.as_ref() { for tool_call in tool_calls { let entry = self.tool_calls_by_index.entry(tool_call.index).or_default(); if let Some(tool_id) = tool_call.id.clone() { entry.id = tool_id; } if let Some(function) = tool_call.function.as_ref() { if let Some(name) = function.name.clone() { entry.name = name; }