use anyhow::{anyhow, Result}; use collections::BTreeMap; use editor::{Editor, EditorElement, EditorStyle}; use futures::{future::BoxFuture, FutureExt, StreamExt}; use gpui::{ AnyView, AppContext, AsyncAppContext, FocusHandle, FocusableView, FontStyle, ModelContext, Subscription, Task, TextStyle, View, WhiteSpace, }; use http_client::HttpClient; use open_ai::stream_completion; use schemars::JsonSchema; use serde::{Deserialize, Serialize}; use settings::{Settings, SettingsStore}; use std::{future, sync::Arc, time::Duration}; use strum::IntoEnumIterator; use theme::ThemeSettings; use ui::{prelude::*, Indicator}; use util::ResultExt; use crate::{ settings::AllLanguageModelSettings, LanguageModel, LanguageModelId, LanguageModelName, LanguageModelProvider, LanguageModelProviderId, LanguageModelProviderName, LanguageModelProviderState, LanguageModelRequest, RateLimiter, Role, }; const PROVIDER_ID: &str = "openai"; const PROVIDER_NAME: &str = "OpenAI"; #[derive(Default, Clone, Debug, PartialEq)] pub struct OpenAiSettings { pub api_url: String, pub low_speed_timeout: Option, pub available_models: Vec, pub needs_setting_migration: bool, } #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, JsonSchema)] pub struct AvailableModel { pub name: String, pub max_tokens: usize, } pub struct OpenAiLanguageModelProvider { http_client: Arc, state: gpui::Model, } pub struct State { api_key: Option, _subscription: Subscription, } impl State { fn is_authenticated(&self) -> bool { self.api_key.is_some() } fn reset_api_key(&self, cx: &mut ModelContext) -> Task> { let settings = &AllLanguageModelSettings::get_global(cx).openai; let delete_credentials = cx.delete_credentials(&settings.api_url); cx.spawn(|this, mut cx| async move { delete_credentials.await.log_err(); this.update(&mut cx, |this, cx| { this.api_key = None; cx.notify(); }) }) } } impl OpenAiLanguageModelProvider { pub fn new(http_client: Arc, cx: &mut AppContext) -> Self { let state = cx.new_model(|cx| State { api_key: None, _subscription: cx.observe_global::(|_this: &mut State, cx| { cx.notify(); }), }); Self { http_client, state } } } impl LanguageModelProviderState for OpenAiLanguageModelProvider { type ObservableEntity = State; fn observable_entity(&self) -> Option> { Some(self.state.clone()) } } impl LanguageModelProvider for OpenAiLanguageModelProvider { fn id(&self) -> LanguageModelProviderId { LanguageModelProviderId(PROVIDER_ID.into()) } fn name(&self) -> LanguageModelProviderName { LanguageModelProviderName(PROVIDER_NAME.into()) } fn icon(&self) -> IconName { IconName::AiOpenAi } fn provided_models(&self, cx: &AppContext) -> Vec> { let mut models = BTreeMap::default(); // Add base models from open_ai::Model::iter() for model in open_ai::Model::iter() { if !matches!(model, open_ai::Model::Custom { .. }) { models.insert(model.id().to_string(), model); } } // Override with available models from settings for model in &AllLanguageModelSettings::get_global(cx) .openai .available_models { models.insert( model.name.clone(), open_ai::Model::Custom { name: model.name.clone(), max_tokens: model.max_tokens, }, ); } models .into_values() .map(|model| { Arc::new(OpenAiLanguageModel { 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 }) .collect() } fn is_authenticated(&self, cx: &AppContext) -> bool { self.state.read(cx).is_authenticated() } fn authenticate(&self, cx: &mut AppContext) -> Task> { if self.is_authenticated(cx) { Task::ready(Ok(())) } else { let api_url = AllLanguageModelSettings::get_global(cx) .openai .api_url .clone(); let state = self.state.clone(); cx.spawn(|mut cx| async move { let api_key = if let Ok(api_key) = std::env::var("OPENAI_API_KEY") { api_key } else { let (_, api_key) = cx .update(|cx| cx.read_credentials(&api_url))? .await? .ok_or_else(|| anyhow!("credentials not found"))?; String::from_utf8(api_key)? }; state.update(&mut cx, |this, cx| { this.api_key = Some(api_key); cx.notify(); }) }) } } fn configuration_view(&self, cx: &mut WindowContext) -> (AnyView, Option) { let view = cx.new_view(|cx| ConfigurationView::new(self.state.clone(), cx)); let focus_handle = view.focus_handle(cx); (view.into(), Some(focus_handle)) } fn reset_credentials(&self, cx: &mut AppContext) -> Task> { self.state.update(cx, |state, cx| state.reset_api_key(cx)) } } pub struct OpenAiLanguageModel { id: LanguageModelId, model: open_ai::Model, state: gpui::Model, http_client: Arc, request_limiter: RateLimiter, } impl LanguageModel for OpenAiLanguageModel { 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 telemetry_id(&self) -> String { format!("openai/{}", self.model.id()) } fn max_token_count(&self) -> usize { self.model.max_token_count() } fn count_tokens( &self, request: LanguageModelRequest, cx: &AppContext, ) -> BoxFuture<'static, Result> { count_open_ai_tokens(request, self.model.clone(), cx) } fn stream_completion( &self, request: LanguageModelRequest, cx: &AsyncAppContext, ) -> BoxFuture<'static, Result>>> { let request = request.into_open_ai(self.model.id().into()); let http_client = self.http_client.clone(); let Ok((api_key, api_url, low_speed_timeout)) = cx.read_model(&self.state, |state, cx| { let settings = &AllLanguageModelSettings::get_global(cx).openai; ( state.api_key.clone(), settings.api_url.clone(), settings.low_speed_timeout, ) }) else { return futures::future::ready(Err(anyhow!("App state dropped"))).boxed(); }; let future = self.request_limiter.stream(async move { let api_key = api_key.ok_or_else(|| anyhow!("missing api key"))?; let request = stream_completion( http_client.as_ref(), &api_url, &api_key, request, low_speed_timeout, ); let response = request.await?; Ok(open_ai::extract_text_from_events(response).boxed()) }); async move { Ok(future.await?.boxed()) }.boxed() } fn use_any_tool( &self, _request: LanguageModelRequest, _name: String, _description: String, _schema: serde_json::Value, _cx: &AsyncAppContext, ) -> BoxFuture<'static, Result> { future::ready(Err(anyhow!("not implemented"))).boxed() } } pub fn count_open_ai_tokens( request: LanguageModelRequest, model: open_ai::Model, cx: &AppContext, ) -> BoxFuture<'static, Result> { cx.background_executor() .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.content), name: None, function_call: None, }) .collect::>(); if let open_ai::Model::Custom { .. } = model { tiktoken_rs::num_tokens_from_messages("gpt-4", &messages) } else { tiktoken_rs::num_tokens_from_messages(model.id(), &messages) } }) .boxed() } struct ConfigurationView { focus_handle: FocusHandle, api_key_editor: View, state: gpui::Model, } impl ConfigurationView { fn new(state: gpui::Model, cx: &mut ViewContext) -> Self { let focus_handle = cx.focus_handle(); cx.on_focus(&focus_handle, |this, cx| { if this.should_render_editor(cx) { this.api_key_editor.read(cx).focus_handle(cx).focus(cx) } }) .detach(); Self { api_key_editor: cx.new_view(|cx| { let mut editor = Editor::single_line(cx); editor.set_placeholder_text( "sk-000000000000000000000000000000000000000000000000", cx, ); editor }), state, focus_handle, } } fn save_api_key(&mut self, _: &menu::Confirm, cx: &mut ViewContext) { let api_key = self.api_key_editor.read(cx).text(cx); if api_key.is_empty() { return; } let settings = &AllLanguageModelSettings::get_global(cx).openai; let write_credentials = cx.write_credentials(&settings.api_url, "Bearer", api_key.as_bytes()); let state = self.state.clone(); cx.spawn(|_, mut cx| async move { write_credentials.await?; state.update(&mut cx, |this, cx| { this.api_key = Some(api_key); cx.notify(); }) }) .detach_and_log_err(cx); } fn reset_api_key(&mut self, cx: &mut ViewContext) { self.api_key_editor .update(cx, |editor, cx| editor.set_text("", cx)); self.state.update(cx, |state, cx| { state.reset_api_key(cx).detach_and_log_err(cx); }) } fn render_api_key_editor(&self, cx: &mut ViewContext) -> impl IntoElement { let settings = ThemeSettings::get_global(cx); let text_style = TextStyle { color: cx.theme().colors().text, font_family: settings.ui_font.family.clone(), font_features: settings.ui_font.features.clone(), font_fallbacks: settings.ui_font.fallbacks.clone(), font_size: rems(0.875).into(), font_weight: settings.ui_font.weight, font_style: FontStyle::Normal, line_height: relative(1.3), background_color: None, underline: None, strikethrough: None, white_space: WhiteSpace::Normal, }; EditorElement::new( &self.api_key_editor, EditorStyle { background: cx.theme().colors().editor_background, local_player: cx.theme().players().local(), text: text_style, ..Default::default() }, ) } fn should_render_editor(&self, cx: &mut ViewContext) -> bool { !self.state.read(cx).is_authenticated() } } impl FocusableView for ConfigurationView { fn focus_handle(&self, _cx: &AppContext) -> FocusHandle { self.focus_handle.clone() } } impl Render for ConfigurationView { fn render(&mut self, cx: &mut ViewContext) -> impl IntoElement { const INSTRUCTIONS: [&str; 6] = [ "To use the assistant panel or inline assistant, you need to add your OpenAI API key.", " - You can create an API key at: platform.openai.com/api-keys", " - Make sure your OpenAI account has credits", " - Having a subscription for another service like GitHub Copilot won't work.", "", "Paste your OpenAI API key below and hit enter to use the assistant:", ]; if self.should_render_editor(cx) { v_flex() .id("openai-configuration-view") .track_focus(&self.focus_handle) .size_full() .on_action(cx.listener(Self::save_api_key)) .children( INSTRUCTIONS.map(|instruction| Label::new(instruction).size(LabelSize::Small)), ) .child( h_flex() .w_full() .my_2() .px_2() .py_1() .bg(cx.theme().colors().editor_background) .rounded_md() .child(self.render_api_key_editor(cx)), ) .child( Label::new( "You can also assign the OPENAI_API_KEY environment variable and restart Zed.", ) .size(LabelSize::Small), ) .into_any() } else { h_flex() .id("openai-configuration-view") .track_focus(&self.focus_handle) .size_full() .justify_between() .child( h_flex() .gap_2() .child(Indicator::dot().color(Color::Success)) .child(Label::new("API Key configured").size(LabelSize::Small)), ) .child( Button::new("reset-key", "Reset key") .icon(Some(IconName::Trash)) .icon_size(IconSize::Small) .icon_position(IconPosition::Start) .on_click(cx.listener(|this, _, cx| this.reset_api_key(cx))), ) .into_any() } } }